A guide to Refactoring mock clones in spring-security

Mock Clone Instance #spring-security_MCI_1

• Scope: method level
• Mocked Class: jakarta.servlet.FilterRegistration.Dynamic
• Test Case Count: 15
• MO Count: 15

Reusable Method

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

The refactoring details in each test cases

Test Case ID #spring-security_Test_1_1

Test Case Name: onStartupWhenDefaultContextThenRegistersSpringSecurityFilterChain(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenDefaultContextThenRegistersSpringSecurityFilterChain() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     new AbstractSecurityWebApplicationInitializer() {
     }.onStartup(context);
     assertProxyDefaults(proxyCaptor.getValue());
-    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
+    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
-    verify(registration).setAsyncSupported(true);
+    verify(registration).setAsyncSupported(true);
     verifyNoAddListener(context);
}

@Test

public void onStartupWhenDefaultContextThenRegistersSpringSecurityFilterChain() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    new AbstractSecurityWebApplicationInitializer() {

    }.onStartup(context);

    assertProxyDefaults(proxyCaptor.getValue());

    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(registration).setAsyncSupported(true);

    verifyNoAddListener(context);

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_2

Test Case Name: onStartupWhenConfigurationClassThenAddsContextLoaderListener(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenConfigurationClassThenAddsContextLoaderListener() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     new AbstractSecurityWebApplicationInitializer(MyRootConfiguration.class) {
     }.onStartup(context);
     assertProxyDefaults(proxyCaptor.getValue());
@@
-    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
+    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
-    verify(registration).setAsyncSupported(true);
+    verify(registration).setAsyncSupported(true);
     verify(context).addListener(any(ContextLoaderListener.class));
}

@Test

public void onStartupWhenConfigurationClassThenAddsContextLoaderListener() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    new AbstractSecurityWebApplicationInitializer(MyRootConfiguration.class) {

    }.onStartup(context);

    assertProxyDefaults(proxyCaptor.getValue());

    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(registration).setAsyncSupported(true);

    verify(context).addListener(any(ContextLoaderListener.class));

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_3

Test Case Name: onStartupWhenEnableHttpSessionEventPublisherIsTrueThenAddsHttpSessionEventPublisher(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenEnableHttpSessionEventPublisherIsTrueThenAddsHttpSessionEventPublisher() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected boolean enableHttpSessionEventPublisher() {
             return true;
         }
     }.onStartup(context);
     assertProxyDefaults(proxyCaptor.getValue());
-    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
+    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
-    verify(registration).setAsyncSupported(true);
+    verify(registration).setAsyncSupported(true);
     verify(context).addListener(HttpSessionEventPublisher.class.getName());
}

@Test

public void onStartupWhenEnableHttpSessionEventPublisherIsTrueThenAddsHttpSessionEventPublisher() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected boolean enableHttpSessionEventPublisher() {

            return true;

        }

    }.onStartup(context);

    assertProxyDefaults(proxyCaptor.getValue());

    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(registration).setAsyncSupported(true);

    verify(context).addListener(HttpSessionEventPublisher.class.getName());

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_4

Test Case Name: onStartupWhenCustomSecurityDispatcherTypesThenUses(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenCustomSecurityDispatcherTypesThenUses() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected EnumSet<DispatcherType> getSecurityDispatcherTypes() {
             return EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR, DispatcherType.FORWARD);
         }
     }.onStartup(context);
     assertProxyDefaults(proxyCaptor.getValue());
-    verify(registration).addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR, DispatcherType.FORWARD), false, "/*");
+    verify(registration).addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR, DispatcherType.FORWARD), false, "/*");
-    verify(registration).setAsyncSupported(true);
+    verify(registration).setAsyncSupported(true);
     verifyNoAddListener(context);
}

@Test

public void onStartupWhenCustomSecurityDispatcherTypesThenUses() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected EnumSet<DispatcherType> getSecurityDispatcherTypes() {

            return EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR, DispatcherType.FORWARD);

        }

    }.onStartup(context);

    assertProxyDefaults(proxyCaptor.getValue());

    verify(registration).addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST, DispatcherType.ERROR, DispatcherType.FORWARD), false, "/*");

    verify(registration).setAsyncSupported(true);

    verifyNoAddListener(context);

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_5

Test Case Name: onStartupWhenCustomDispatcherWebApplicationContextSuffixThenUses(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenCustomDispatcherWebApplicationContextSuffixThenUses() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected String getDispatcherWebApplicationContextSuffix() {
             return "dispatcher";
         }
     }.onStartup(context);
     DelegatingFilterProxy proxy = proxyCaptor.getValue();
     assertThat(proxy.getContextAttribute()).isEqualTo("org.springframework.web.servlet.FrameworkServlet.CONTEXT.dispatcher");
     assertThat(proxy).hasFieldOrPropertyWithValue("targetBeanName", "springSecurityFilterChain");
-    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
+    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
-    verify(registration).setAsyncSupported(true);
+    verify(registration).setAsyncSupported(true);
     verifyNoAddListener(context);
}

@Test

public void onStartupWhenCustomDispatcherWebApplicationContextSuffixThenUses() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected String getDispatcherWebApplicationContextSuffix() {

            return "dispatcher";

        }

    }.onStartup(context);

    DelegatingFilterProxy proxy = proxyCaptor.getValue();

    assertThat(proxy.getContextAttribute()).isEqualTo("org.springframework.web.servlet.FrameworkServlet.CONTEXT.dispatcher");

    assertThat(proxy).hasFieldOrPropertyWithValue("targetBeanName", "springSecurityFilterChain");

    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(registration).setAsyncSupported(true);

    verifyNoAddListener(context);

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_6

Test Case Name: onStartupWhenInsertFiltersThenInserted(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenInsertFiltersThenInserted() {
     Filter filter1 = mock(Filter.class);
     Filter filter2 = mock(Filter.class);
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     given(context.addFilter(anyString(), eq(filter1))).willReturn(registration);
     given(context.addFilter(anyString(), eq(filter2))).willReturn(registration);
     new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             insertFilters(context, filter1, filter2);
         }
     }.onStartup(context);
     assertProxyDefaults(proxyCaptor.getValue());
-    verify(registration, times(3)).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
+    verify(registration, times(3)).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
-    verify(registration, times(3)).setAsyncSupported(true);
+    verify(registration, times(3)).setAsyncSupported(true);
     verifyNoAddListener(context);
     verify(context).addFilter(anyString(), eq(filter1));
     verify(context).addFilter(anyString(), eq(filter2));
}

@Test

public void onStartupWhenInsertFiltersThenInserted() {

    Filter filter1 = mock(Filter.class);

    Filter filter2 = mock(Filter.class);

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    given(context.addFilter(anyString(), eq(filter1))).willReturn(registration);

    given(context.addFilter(anyString(), eq(filter2))).willReturn(registration);

    new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            insertFilters(context, filter1, filter2);

        }

    }.onStartup(context);

    assertProxyDefaults(proxyCaptor.getValue());

    verify(registration, times(3)).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(registration, times(3)).setAsyncSupported(true);

    verifyNoAddListener(context);

    verify(context).addFilter(anyString(), eq(filter1));

    verify(context).addFilter(anyString(), eq(filter2));

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_7

Test Case Name: onStartupWhenDuplicateFilterInsertedThenException(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenDuplicateFilterInsertedThenException() {
     Filter filter1 = mock(Filter.class);
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     assertThatIllegalStateException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             insertFilters(context, filter1);
         }
     }.onStartup(context)).withMessage("Duplicate Filter registration for 'object'. Check to ensure the Filter is only configured once.");
     assertProxyDefaults(proxyCaptor.getValue());
-    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
+    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
     verify(context).addFilter(anyString(), eq(filter1));
}

@Test

public void onStartupWhenDuplicateFilterInsertedThenException() {

    Filter filter1 = mock(Filter.class);

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    assertThatIllegalStateException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            insertFilters(context, filter1);

        }

    }.onStartup(context)).withMessage("Duplicate Filter registration for 'object'. Check to ensure the Filter is only configured once.");

    assertProxyDefaults(proxyCaptor.getValue());

    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(context).addFilter(anyString(), eq(filter1));

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_8

Test Case Name: onStartupWhenInsertFiltersEmptyThenException(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenInsertFiltersEmptyThenException() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             insertFilters(context);
         }
     }.onStartup(context)).withMessage("filters cannot be null or empty");
     assertProxyDefaults(proxyCaptor.getValue());
 }

@Test

public void onStartupWhenInsertFiltersEmptyThenException() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            insertFilters(context);

        }

    }.onStartup(context)).withMessage("filters cannot be null or empty");

    assertProxyDefaults(proxyCaptor.getValue());

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_9

Test Case Name: onStartupWhenNullFilterInsertedThenException(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenNullFilterInsertedThenException() {
     Filter filter = mock(Filter.class);
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     given(context.addFilter(anyString(), eq(filter))).willReturn(registration);
     assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             insertFilters(context, filter, null);
         }
     }.onStartup(context)).withMessageContaining("filters cannot contain null values");
     verify(context, times(2)).addFilter(anyString(), any(Filter.class));
}

@Test

public void onStartupWhenNullFilterInsertedThenException() {

    Filter filter = mock(Filter.class);

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    given(context.addFilter(anyString(), eq(filter))).willReturn(registration);

    assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            insertFilters(context, filter, null);

        }

    }.onStartup(context)).withMessageContaining("filters cannot contain null values");

    verify(context, times(2)).addFilter(anyString(), any(Filter.class));

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_10

Test Case Name: onStartupWhenAppendFiltersThenAppended(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenAppendFiltersThenAppended() {
     Filter filter1 = mock(Filter.class);
     Filter filter2 = mock(Filter.class);
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     given(context.addFilter(anyString(), eq(filter1))).willReturn(registration);
     given(context.addFilter(anyString(), eq(filter2))).willReturn(registration);
     new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             appendFilters(context, filter1, filter2);
         }
     }.onStartup(context);
     verify(registration, times(1)).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
     verify(registration, times(2)).addMappingForUrlPatterns(DEFAULT_DISPATCH, true, "/*");
     verify(registration, times(3)).setAsyncSupported(true);
     verifyNoAddListener(context);
     verify(context, times(3)).addFilter(anyString(), any(Filter.class));
}

@Test

public void onStartupWhenAppendFiltersThenAppended() {

    Filter filter1 = mock(Filter.class);

    Filter filter2 = mock(Filter.class);

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    given(context.addFilter(anyString(), eq(filter1))).willReturn(registration);

    given(context.addFilter(anyString(), eq(filter2))).willReturn(registration);

    new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            appendFilters(context, filter1, filter2);

        }

    }.onStartup(context);

    verify(registration, times(1)).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(registration, times(2)).addMappingForUrlPatterns(DEFAULT_DISPATCH, true, "/*");

    verify(registration, times(3)).setAsyncSupported(true);

    verifyNoAddListener(context);

    verify(context, times(3)).addFilter(anyString(), any(Filter.class));

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_11

Test Case Name: onStartupWhenDuplicateFilterAppendedThenException(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenDuplicateFilterAppendedThenException() {
     Filter filter1 = mock(Filter.class);
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     assertThatIllegalStateException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             appendFilters(context, filter1);
         }
     }.onStartup(context)).withMessage("Duplicate Filter registration for 'object'. " + "Check to ensure the Filter is only configured once.");
     assertProxyDefaults(proxyCaptor.getValue());
-    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
+    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");
     verify(context).addFilter(anyString(), eq(filter1));
}

@Test

public void onStartupWhenDuplicateFilterAppendedThenException() {

    Filter filter1 = mock(Filter.class);

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    assertThatIllegalStateException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            appendFilters(context, filter1);

        }

    }.onStartup(context)).withMessage("Duplicate Filter registration for 'object'. " + "Check to ensure the Filter is only configured once.");

    assertProxyDefaults(proxyCaptor.getValue());

    verify(registration).addMappingForUrlPatterns(DEFAULT_DISPATCH, false, "/*");

    verify(context).addFilter(anyString(), eq(filter1));

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_12

Test Case Name: onStartupWhenAppendFiltersEmptyThenException(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenAppendFiltersEmptyThenException() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             appendFilters(context);
         }
     }.onStartup(context)).withMessage("filters cannot be null or empty");
     assertProxyDefaults(proxyCaptor.getValue());
 }

@Test

public void onStartupWhenAppendFiltersEmptyThenException() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            appendFilters(context);

        }

    }.onStartup(context)).withMessage("filters cannot be null or empty");

    assertProxyDefaults(proxyCaptor.getValue());

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_13

Test Case Name: onStartupWhenNullFilterAppendedThenException(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenNullFilterAppendedThenException() {
     Filter filter = mock(Filter.class);
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);
     given(context.addFilter(anyString(), eq(filter))).willReturn(registration);
     assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {

         @Override
         protected void afterSpringSecurityFilterChain(ServletContext servletContext) {
             appendFilters(context, filter, null);
         }
     }.onStartup(context)).withMessageContaining("filters cannot contain null values");
     verify(context, times(2)).addFilter(anyString(), any(Filter.class));
}

@Test

public void onStartupWhenNullFilterAppendedThenException() {

    Filter filter = mock(Filter.class);

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture())).willReturn(registration);

    given(context.addFilter(anyString(), eq(filter))).willReturn(registration);

    assertThatIllegalArgumentException().isThrownBy(() -> new AbstractSecurityWebApplicationInitializer() {



        @Override

        protected void afterSpringSecurityFilterChain(ServletContext servletContext) {

            appendFilters(context, filter, null);

        }

    }.onStartup(context)).withMessageContaining("filters cannot contain null values");

    verify(context, times(2)).addFilter(anyString(), any(Filter.class));

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_14

Test Case Name: onStartupWhenDefaultsThenSessionTrackingModes(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenDefaultsThenSessionTrackingModes() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), any(DelegatingFilterProxy.class))).willReturn(registration);
     @SuppressWarnings("unchecked")
     ArgumentCaptor<Set<SessionTrackingMode>> modesCaptor = ArgumentCaptor.forClass(Set.class);
     new AbstractSecurityWebApplicationInitializer() {
     }.onStartup(context);
     verify(context).addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture());
     assertProxyDefaults(proxyCaptor.getValue());
     verify(context).setSessionTrackingModes(modesCaptor.capture());
     Set<SessionTrackingMode> modes = modesCaptor.getValue();
     assertThat(modes).hasSize(1);
     assertThat(modes).containsExactly(SessionTrackingMode.COOKIE);
}

@Test

public void onStartupWhenDefaultsThenSessionTrackingModes() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), any(DelegatingFilterProxy.class))).willReturn(registration);

    @SuppressWarnings("unchecked")

    ArgumentCaptor<Set<SessionTrackingMode>> modesCaptor = ArgumentCaptor.forClass(Set.class);

    new AbstractSecurityWebApplicationInitializer() {

    }.onStartup(context);

    verify(context).addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture());

    assertProxyDefaults(proxyCaptor.getValue());

    verify(context).setSessionTrackingModes(modesCaptor.capture());

    Set<SessionTrackingMode> modes = modesCaptor.getValue();

    assertThat(modes).hasSize(1);

    assertThat(modes).containsExactly(SessionTrackingMode.COOKIE);

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Test Case ID #spring-security_Test_1_15

Test Case Name: onStartupWhenSessionTrackingModesConfiguredThenUsed(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\context\AbstractSecurityWebApplicationInitializerTests.java)

Mock Object Variable Name: registration

@@
 @Test
 public void onStartupWhenSessionTrackingModesConfiguredThenUsed() {
     ServletContext context = mock(ServletContext.class);
-    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);
+    // removed local mock; replaced with global field `registration`
     ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);
     given(context.addFilter(eq("springSecurityFilterChain"), any(DelegatingFilterProxy.class))).willReturn(registration);
     @SuppressWarnings("unchecked")
     ArgumentCaptor<Set<SessionTrackingMode>> modesCaptor = ArgumentCaptor.forClass(Set.class);
     willDoNothing().given(context).setSessionTrackingModes(any());
     new AbstractSecurityWebApplicationInitializer() {

         @Override
         public Set<SessionTrackingMode> getSessionTrackingModes() {
             return Collections.singleton(SessionTrackingMode.SSL);
         }
     }.onStartup(context);
     verify(context).addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture());
     assertProxyDefaults(proxyCaptor.getValue());
     verify(context).setSessionTrackingModes(modesCaptor.capture());
     Set<SessionTrackingMode> modes = modesCaptor.getValue();
     assertThat(modes).hasSize(1);
     assertThat(modes).containsExactly(SessionTrackingMode.SSL);
}

@Test

public void onStartupWhenSessionTrackingModesConfiguredThenUsed() {

    ServletContext context = mock(ServletContext.class);

    FilterRegistration.Dynamic registration = mock(FilterRegistration.Dynamic.class);

    ArgumentCaptor<DelegatingFilterProxy> proxyCaptor = ArgumentCaptor.forClass(DelegatingFilterProxy.class);

    given(context.addFilter(eq("springSecurityFilterChain"), any(DelegatingFilterProxy.class))).willReturn(registration);

    @SuppressWarnings("unchecked")

    ArgumentCaptor<Set<SessionTrackingMode>> modesCaptor = ArgumentCaptor.forClass(Set.class);

    willDoNothing().given(context).setSessionTrackingModes(any());

    new AbstractSecurityWebApplicationInitializer() {



        @Override

        public Set<SessionTrackingMode> getSessionTrackingModes() {

            return Collections.singleton(SessionTrackingMode.SSL);

        }

    }.onStartup(context);

    verify(context).addFilter(eq("springSecurityFilterChain"), proxyCaptor.capture());

    assertProxyDefaults(proxyCaptor.getValue());

    verify(context).setSessionTrackingModes(modesCaptor.capture());

    Set<SessionTrackingMode> modes = modesCaptor.getValue();

    assertThat(modes).hasSize(1);

    assertThat(modes).containsExactly(SessionTrackingMode.SSL);

}

// === Declare in class scope ===
private FilterRegistration.Dynamic registration;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registration = mock(FilterRegistration.Dynamic.class);
}

// === Replace local variable in test with ===
registration;

Mock Clone Instance #spring-security_MCI_2

• Scope: method level
• Mocked Class: java.util.function.Supplier<org.springframework.security.oauth2.jwt.ReactiveJwtDecoder>
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static Supplier<ReactiveJwtDecoder> createMockBrokenSupplier() {
    Supplier<ReactiveJwtDecoder> broken = mock(Supplier.class);
    given(broken.get()).willThrow(RuntimeException.class);
    return broken;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_2_1

Test Case Name: decodeWhenInitializationFailsThenInitializationException(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\SupplierReactiveJwtDecoderTests.java)

Mock Object Variable Name: broken

@@
 @Test
 public void decodeWhenInitializationFailsThenInitializationException() {
-    Supplier<ReactiveJwtDecoder> broken = mock(Supplier.class);
-    given(broken.get()).willThrow(RuntimeException.class);
+    Supplier<ReactiveJwtDecoder> broken = createMockBrokenSupplier();
     ReactiveJwtDecoder jwtDecoder = new SupplierReactiveJwtDecoder(broken);
     assertThatExceptionOfType(JwtDecoderInitializationException.class).isThrownBy(() -> jwtDecoder.decode("token").block());
     verify(broken).get();
 }

@Test

public void decodeWhenInitializationFailsThenInitializationException() {

    Supplier<ReactiveJwtDecoder> broken = mock(Supplier.class);

    given(broken.get()).willThrow(RuntimeException.class);

    ReactiveJwtDecoder jwtDecoder = new SupplierReactiveJwtDecoder(broken);

    assertThatExceptionOfType(JwtDecoderInitializationException.class).isThrownBy(() -> jwtDecoder.decode("token").block());

    verify(broken).get();

}

private static Supplier<ReactiveJwtDecoder> createMockBrokenSupplier() {
    Supplier<ReactiveJwtDecoder> broken = mock(Supplier.class);
    given(broken.get()).willThrow(RuntimeException.class);
    return broken;
}

Test Case ID #spring-security_Test_2_2

Test Case Name: decodeWhenInitializationInitiallyFailsThenRecoverable(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\SupplierReactiveJwtDecoderTests.java)

Mock Object Variable Name: broken

@@
     ReactiveJwtDecoder jwtDecoder = mock(ReactiveJwtDecoder.class);
-    Supplier<ReactiveJwtDecoder> broken = mock(Supplier.class);
-    given(broken.get()).willThrow(RuntimeException.class);
+    Supplier<ReactiveJwtDecoder> broken = createMockBrokenSupplier();
     given(jwtDecoder.decode("token")).willReturn(Mono.empty());
     ReactiveJwtDecoder supplierReactiveJwtDecoder = new SupplierReactiveJwtDecoder(broken);
     assertThatExceptionOfType(JwtDecoderInitializationException.class).isThrownBy(() -> supplierReactiveJwtDecoder.decode("token").block());
     reset(broken);
     given(broken.get()).willReturn(jwtDecoder);
     supplierReactiveJwtDecoder.decode("token").block();
     verify(jwtDecoder).decode("token");
@@

@Test

public void decodeWhenInitializationInitiallyFailsThenRecoverable() {

    ReactiveJwtDecoder jwtDecoder = mock(ReactiveJwtDecoder.class);

    Supplier<ReactiveJwtDecoder> broken = mock(Supplier.class);

    given(broken.get()).willThrow(RuntimeException.class);

    given(jwtDecoder.decode("token")).willReturn(Mono.empty());

    ReactiveJwtDecoder supplierReactiveJwtDecoder = new SupplierReactiveJwtDecoder(broken);

    assertThatExceptionOfType(JwtDecoderInitializationException.class).isThrownBy(() -> supplierReactiveJwtDecoder.decode("token").block());

    reset(broken);

    given(broken.get()).willReturn(jwtDecoder);

    supplierReactiveJwtDecoder.decode("token").block();

    verify(jwtDecoder).decode("token");

}

private static Supplier<ReactiveJwtDecoder> createMockBrokenSupplier() {
    Supplier<ReactiveJwtDecoder> broken = mock(Supplier.class);
    given(broken.get()).willThrow(RuntimeException.class);
    return broken;
}

Mock Clone Instance #spring-security_MCI_3

• Scope: method level
• Mocked Class: org.springframework.security.authorization.AuthorizationManager<org.springframework.security.authorization.method.MethodInvocationResult>
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static AuthorizationManager<MethodInvocationResult> createMockAuthorizationManager() {
    AuthorizationManager<MethodInvocationResult> mockAuthorizationManager = mock(AuthorizationManager.class);
    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockAuthorizationManager;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_3_1

Test Case Name: beforeWhenMockAuthorizationManagerThenCheckAndReturnedObject(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authorization\method\AuthorizationManagerAfterMethodInterceptorTests.java)

Mock Object Variable Name: mockAuthorizationManager

--- original
+++ refactored
@@
    given(mockMethodInvocation.proceed()).willReturn(result.getResult());
-    AuthorizationManager<MethodInvocationResult> mockAuthorizationManager = mock(AuthorizationManager.class);
-    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
+    AuthorizationManager<MethodInvocationResult> mockAuthorizationManager = createMockAuthorizationManager();
    AuthorizationManagerAfterMethodInterceptor advice = new AuthorizationManagerAfterMethodInterceptor(Pointcut.TRUE, mockAuthorizationManager);
    Object returnedObject = advice.invoke(mockMethodInvocation);
    assertThat(returnedObject).isEqualTo(result.getResult());
    verify(mockAuthorizationManager).check(any(Supplier.class), any(MethodInvocationResult.class));
@@

@Test

public void beforeWhenMockAuthorizationManagerThenCheckAndReturnedObject() throws Throwable {

    MethodInvocation mockMethodInvocation = mock(MethodInvocation.class);

    MethodInvocationResult result = new MethodInvocationResult(mockMethodInvocation, new Object());

    given(mockMethodInvocation.proceed()).willReturn(result.getResult());

    AuthorizationManager<MethodInvocationResult> mockAuthorizationManager = mock(AuthorizationManager.class);

    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();

    AuthorizationManagerAfterMethodInterceptor advice = new AuthorizationManagerAfterMethodInterceptor(Pointcut.TRUE, mockAuthorizationManager);

    Object returnedObject = advice.invoke(mockMethodInvocation);

    assertThat(returnedObject).isEqualTo(result.getResult());

    verify(mockAuthorizationManager).check(any(Supplier.class), any(MethodInvocationResult.class));

}

private static AuthorizationManager<MethodInvocationResult> createMockAuthorizationManager() {
    AuthorizationManager<MethodInvocationResult> mockAuthorizationManager = mock(AuthorizationManager.class);
    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockAuthorizationManager;
}

Test Case ID #spring-security_Test_3_2

Test Case Name: invokeWhenCustomAuthorizationDeniedExceptionThenThrows(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authorization\method\AuthorizationManagerAfterMethodInterceptorTests.java)

Mock Object Variable Name: manager

@@
    given(mi.proceed()).willReturn("ok");
-    AuthorizationManager<MethodInvocationResult> manager = mock(AuthorizationManager.class);
-    given(manager.check(any(), any())).willThrow(new MyAuthzDeniedException("denied", new AuthorizationDecision(false)));
-    given(manager.authorize(any(), any())).willCallRealMethod();
+    AuthorizationManager<MethodInvocationResult> manager = createMockAuthorizationManager();
+    given(manager.check(any(), any())).willThrow(new MyAuthzDeniedException("denied", new AuthorizationDecision(false)));
    AuthorizationManagerAfterMethodInterceptor advice = new AuthorizationManagerAfterMethodInterceptor(Pointcut.TRUE, manager);
    assertThatExceptionOfType(MyAuthzDeniedException.class).isThrownBy(() -> advice.invoke(mi));
@@

@Test

public void invokeWhenCustomAuthorizationDeniedExceptionThenThrows() throws Throwable {

    MethodInvocation mi = mock(MethodInvocation.class);

    given(mi.proceed()).willReturn("ok");

    AuthorizationManager<MethodInvocationResult> manager = mock(AuthorizationManager.class);

    given(manager.check(any(), any())).willThrow(new MyAuthzDeniedException("denied", new AuthorizationDecision(false)));

    given(manager.authorize(any(), any())).willCallRealMethod();

    AuthorizationManagerAfterMethodInterceptor advice = new AuthorizationManagerAfterMethodInterceptor(Pointcut.TRUE, manager);

    assertThatExceptionOfType(MyAuthzDeniedException.class).isThrownBy(() -> advice.invoke(mi));

}

private static AuthorizationManager<MethodInvocationResult> createMockAuthorizationManager() {
    AuthorizationManager<MethodInvocationResult> mockAuthorizationManager = mock(AuthorizationManager.class);
    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockAuthorizationManager;
}

Mock Clone Instance #spring-security_MCI_4

• Scope: class level
• Mocked Class: org.springframework.web.server.WebFilter
• Test Case Count: 2
• MO Count: 2

Reusable Method

public class MockWebFilter {

    /**
     * Creates a mock WebFilter with the given Mono to return from filter().
     *
     * @param monoReturn the Mono to return from filter(ServerWebExchange, WebFilterChain)
     * @return the configured mock WebFilter
     */
    public static org.springframework.web.server.WebFilter createMockWebFilter(reactor.core.publisher.Mono<?> monoReturn) {
        org.springframework.web.server.WebFilter mock = mock(org.springframework.web.server.WebFilter.class);
        given(mock.filter(any(), any())).willReturn(monoReturn);
        return mock;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_4_1

Test Case Name: decorateWhenCustomAfterFilterThenObserves(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\server\ObservationWebFilterChainDecoratorTests.java)

Mock Object Variable Name: mock

--- original
+++ refactored
@@
    registry.observationConfig().observationHandler(handler);
    ObservationWebFilterChainDecorator decorator = new ObservationWebFilterChainDecorator(registry);
-    WebFilter mock = mock(WebFilter.class);
-    given(mock.filter(any(), any())).willReturn(Mono.empty());
+    WebFilter mock = MockWebFilter.createMockWebFilter(Mono.empty());
    WebFilterChain chain = mock(WebFilterChain.class);
    given(chain.filter(any())).willReturn(Mono.empty());
    WebFilterChain decorated = decorator.decorate(chain, List.of((e, c) -> c.filter(e).then(Mono.deferContextual((context) -> {
        Observation parentObservation = context.getOrDefault(ObservationThreadLocalAccessor.KEY, null);
        Observation observation = Observation.createNotStarted("custom", registry).parentObservation(parentObservation).contextualName("custom").start();
        return Mono.just("3").doOnSuccess((v) -> observation.stop()).doOnCancel(observation::stop).doOnError((t) -> {
            observation.error(t);
            observation.stop();
        }).then(Mono.empty());
    }))));
@@

// gh-12849

@Test

void decorateWhenCustomAfterFilterThenObserves() {

    AccumulatingObservationHandler handler = new AccumulatingObservationHandler();

    ObservationRegistry registry = ObservationRegistry.create();

    registry.observationConfig().observationHandler(handler);

    ObservationWebFilterChainDecorator decorator = new ObservationWebFilterChainDecorator(registry);

    WebFilter mock = mock(WebFilter.class);

    given(mock.filter(any(), any())).willReturn(Mono.empty());

    WebFilterChain chain = mock(WebFilterChain.class);

    given(chain.filter(any())).willReturn(Mono.empty());

    WebFilterChain decorated = decorator.decorate(chain, List.of((e, c) -> c.filter(e).then(Mono.deferContextual((context) -> {

        Observation parentObservation = context.getOrDefault(ObservationThreadLocalAccessor.KEY, null);

        Observation observation = Observation.createNotStarted("custom", registry).parentObservation(parentObservation).contextualName("custom").start();

        return Mono.just("3").doOnSuccess((v) -> observation.stop()).doOnCancel(observation::stop).doOnError((t) -> {

            observation.error(t);

            observation.stop();

        }).then(Mono.empty());

    }))));

    Observation http = Observation.start("http", registry).contextualName("http");

    try {

        decorated.filter(MockServerWebExchange.from(MockServerHttpRequest.get("/").build())).contextWrite((context) -> context.put(ObservationThreadLocalAccessor.KEY, http)).block();

    } finally {

        http.stop();

    }

    handler.assertSpanStart(0, "http", null);

    handler.assertSpanStart(1, "spring.security.filterchains", "http");

    handler.assertSpanStop(2, "security filterchain before");

    handler.assertSpanStart(3, "secured request", "security filterchain before");

    handler.assertSpanStop(4, "secured request");

    handler.assertSpanStart(5, "spring.security.filterchains", "http");

    handler.assertSpanStart(6, "custom", "spring.security.filterchains");

    handler.assertSpanStop(7, "custom");

    handler.assertSpanStop(8, "security filterchain after");

    handler.assertSpanStop(9, "http");

}

public class MockWebFilter {

    /**
     * Creates a mock WebFilter with the given Mono to return from filter().
     *
     * @param monoReturn the Mono to return from filter(ServerWebExchange, WebFilterChain)
     * @return the configured mock WebFilter
     */
    public static org.springframework.web.server.WebFilter createMockWebFilter(reactor.core.publisher.Mono<?> monoReturn) {
        org.springframework.web.server.WebFilter mock = mock(org.springframework.web.server.WebFilter.class);
        given(mock.filter(any(), any())).willReturn(monoReturn);
        return mock;
    }
}

Test Case ID #spring-security_Test_4_2

Test Case Name: doFilterWhenFilterExceptionThenObservationRegistryObserves(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\server\WebFilterChainProxyTests.java)

Mock Object Variable Name: error

--- original
+++ refactored
@@
    ObservationRegistry registry = ObservationRegistry.create();
    registry.observationConfig().observationHandler(handler);
-    WebFilter error = mock(WebFilter.class);
-    given(error.filter(any(), any())).willReturn(Mono.error(new IllegalStateException()));
+    WebFilter error = MockWebFilter.createMockWebFilter(Mono.error(new IllegalStateException()));
    List<WebFilter> filters = Arrays.asList(error);
    ServerWebExchangeMatcher match = (exchange) -> MatchResult.match();
    MatcherSecurityWebFilterChain chain = new MatcherSecurityWebFilterChain(match, filters);
@@

@Test

public void doFilterWhenFilterExceptionThenObservationRegistryObserves() {

    ObservationHandler<Observation.Context> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.create();

    registry.observationConfig().observationHandler(handler);

    WebFilter error = mock(WebFilter.class);

    given(error.filter(any(), any())).willReturn(Mono.error(new IllegalStateException()));

    List<WebFilter> filters = Arrays.asList(error);

    ServerWebExchangeMatcher match = (exchange) -> MatchResult.match();

    MatcherSecurityWebFilterChain chain = new MatcherSecurityWebFilterChain(match, filters);

    WebFilterChainProxy fcp = new WebFilterChainProxy(chain);

    fcp.setFilterChainDecorator(new ObservationWebFilterChainDecorator(registry));

    WebFilter filter = WebFilterObservation.create(Observation.createNotStarted("wrap", registry)).wrap(fcp);

    WebFilterChain mockChain = mock(WebFilterChain.class);

    given(mockChain.filter(any())).willReturn(Mono.empty());

    assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> filter.filter(MockServerWebExchange.from(MockServerHttpRequest.get("/")), mockChain).block());

    ArgumentCaptor<Observation.Context> captor = ArgumentCaptor.forClass(Observation.Context.class);

    verify(handler, times(2)).onStart(captor.capture());

    verify(handler, atLeastOnce()).onError(any());

    Iterator<Observation.Context> contexts = captor.getAllValues().iterator();

    assertThat(contexts.next().getName()).isEqualTo("wrap");

    assertFilterChainObservation(contexts.next(), "before", 1);

}

public class MockWebFilter {

    /**
     * Creates a mock WebFilter with the given Mono to return from filter().
     *
     * @param monoReturn the Mono to return from filter(ServerWebExchange, WebFilterChain)
     * @return the configured mock WebFilter
     */
    public static org.springframework.web.server.WebFilter createMockWebFilter(reactor.core.publisher.Mono<?> monoReturn) {
        org.springframework.web.server.WebFilter mock = mock(org.springframework.web.server.WebFilter.class);
        given(mock.filter(any(), any())).willReturn(monoReturn);
        return mock;
    }
}

Mock Clone Instance #spring-security_MCI_5

• Scope: class level
• Mocked Class: org.springframework.web.reactive.function.BodyExtractor<reactor.core.publisher.Mono<org.springframework.security.oauth2.core.endpoint.OAuth2AccessTokenResponse>, org.springframework.http.ReactiveHttpInputMessage>
• Test Case Count: 2
• MO Count: 5

Reusable Method

public class MockBodyExtractor {
    public static BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> createMockBodyExtractor(OAuth2AccessTokenResponse response) {
        BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
        given(extractor.extract(any(), any())).willReturn(Mono.just(response));
        return extractor;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_5_1

Test Case Name: getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactiveAuthorizationCodeTokenResponseClientTests.java)

Mock Object Variable Name: extractor

--- original
+++ refactored
@@
    WebClientReactiveAuthorizationCodeTokenResponseClient customClient = new WebClientReactiveAuthorizationCodeTokenResponseClient();
-    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();
-    given(extractor.extract(any(), any())).willReturn(Mono.just(response));
+    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = MockBodyExtractor.createMockBodyExtractor(response);
    customClient.setBodyExtractor(extractor);
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(authorizationCodeGrantRequest()).block();
    assertThat(accessTokenResponse.getAccessToken()).isNotNull();
}

// gh-10260

@Test

public void getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse() {

    WebClientReactiveAuthorizationCodeTokenResponseClient customClient = new WebClientReactiveAuthorizationCodeTokenResponseClient();

    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();

    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();

    given(extractor.extract(any(), any())).willReturn(Mono.just(response));

    customClient.setBodyExtractor(extractor);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(authorizationCodeGrantRequest()).block();

    assertThat(accessTokenResponse.getAccessToken()).isNotNull();

}

public class MockBodyExtractor {
    public static BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> createMockBodyExtractor(OAuth2AccessTokenResponse response) {
        BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
        given(extractor.extract(any(), any())).willReturn(Mono.just(response));
        return extractor;
    }
}

Test Case ID #spring-security_Test_5_2

Test Case Name: getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactiveClientCredentialsTokenResponseClientTests.java)

Mock Object Variable Name: extractor

--- original
+++ refactored
@@
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    WebClientReactiveClientCredentialsTokenResponseClient customClient = new WebClientReactiveClientCredentialsTokenResponseClient();
-    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();
-    given(extractor.extract(any(), any())).willReturn(Mono.just(response));
+    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = MockBodyExtractor.createMockBodyExtractor(response);
    customClient.setBodyExtractor(extractor);
    OAuth2ClientCredentialsGrantRequest request = new OAuth2ClientCredentialsGrantRequest(this.clientRegistration.build());
    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(request).block();
    assertThat(accessTokenResponse.getAccessToken()).isNotNull();
@@

// gh-10260

@Test

public void getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse() {

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    WebClientReactiveClientCredentialsTokenResponseClient customClient = new WebClientReactiveClientCredentialsTokenResponseClient();

    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();

    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();

    given(extractor.extract(any(), any())).willReturn(Mono.just(response));

    customClient.setBodyExtractor(extractor);

    OAuth2ClientCredentialsGrantRequest request = new OAuth2ClientCredentialsGrantRequest(this.clientRegistration.build());

    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(request).block();

    assertThat(accessTokenResponse.getAccessToken()).isNotNull();

}

public class MockBodyExtractor {
    public static BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> createMockBodyExtractor(OAuth2AccessTokenResponse response) {
        BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
        given(extractor.extract(any(), any())).willReturn(Mono.just(response));
        return extractor;
    }
}

Test Case ID #spring-security_Test_5_3

Test Case Name: getTokenResponseWhenBodyExtractorSetThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactiveJwtBearerTokenResponseClientTests.java)

Mock Object Variable Name: bodyExtractor

@@
    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> bodyExtractor = mock();
    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();
-    given(bodyExtractor.extract(any(), any())).willReturn(Mono.just(response));
+    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> bodyExtractor = MockBodyExtractor.createMockBodyExtractor(response);
    ClientRegistration clientRegistration = this.clientRegistration.build();

@Test

public void getTokenResponseWhenBodyExtractorSetThenCalled() {

    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> bodyExtractor = mock();

    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();

    given(bodyExtractor.extract(any(), any())).willReturn(Mono.just(response));

    ClientRegistration clientRegistration = this.clientRegistration.build();

    JwtBearerGrantRequest request = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);

    this.client.setBodyExtractor(bodyExtractor);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    this.client.getTokenResponse(request).block();

    verify(bodyExtractor).extract(any(), any());

}

public class MockBodyExtractor {
    public static BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> createMockBodyExtractor(OAuth2AccessTokenResponse response) {
        BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
        given(extractor.extract(any(), any())).willReturn(Mono.just(response));
        return extractor;
    }
}

Test Case ID #spring-security_Test_5_4

Test Case Name: getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactivePasswordTokenResponseClientTests.java)

Mock Object Variable Name: extractor

--- original
+++ refactored
@@
    WebClientReactivePasswordTokenResponseClient customClient = new WebClientReactivePasswordTokenResponseClient();
-    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();
-    given(extractor.extract(any(), any())).willReturn(Mono.just(response));
+    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = MockBodyExtractor.createMockBodyExtractor(response);
    customClient.setBodyExtractor(extractor);
    ClientRegistration clientRegistration = this.clientRegistrationBuilder.build();
    OAuth2PasswordGrantRequest passwordGrantRequest = new OAuth2PasswordGrantRequest(clientRegistration, this.username, this.password);
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(passwordGrantRequest).block();
    assertThat(accessTokenResponse.getAccessToken()).isNotNull();
@@

// gh-10260

@Test

public void getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse() {

    WebClientReactivePasswordTokenResponseClient customClient = new WebClientReactivePasswordTokenResponseClient();

    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();

    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();

    given(extractor.extract(any(), any())).willReturn(Mono.just(response));

    customClient.setBodyExtractor(extractor);

    ClientRegistration clientRegistration = this.clientRegistrationBuilder.build();

    OAuth2PasswordGrantRequest passwordGrantRequest = new OAuth2PasswordGrantRequest(clientRegistration, this.username, this.password);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(passwordGrantRequest).block();

    assertThat(accessTokenResponse.getAccessToken()).isNotNull();

}

public class MockBodyExtractor {
    public static BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> createMockBodyExtractor(OAuth2AccessTokenResponse response) {
        BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
        given(extractor.extract(any(), any())).willReturn(Mono.just(response));
        return extractor;
    }
}

Test Case ID #spring-security_Test_5_5

Test Case Name: getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactiveRefreshTokenTokenResponseClientTests.java)

Mock Object Variable Name: extractor

--- original
+++ refactored
@@
    WebClientReactiveRefreshTokenTokenResponseClient customClient = new WebClientReactiveRefreshTokenTokenResponseClient();
-    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();
-    given(extractor.extract(any(), any())).willReturn(Mono.just(response));
+    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = MockBodyExtractor.createMockBodyExtractor(response);
    customClient.setBodyExtractor(extractor);
    OAuth2RefreshTokenGrantRequest refreshTokenGrantRequest = new OAuth2RefreshTokenGrantRequest(this.clientRegistrationBuilder.build(), this.accessToken, this.refreshToken);
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(refreshTokenGrantRequest).block();
    assertThat(accessTokenResponse.getAccessToken()).isNotNull();
}

// gh-10260

@Test

public void getTokenResponseWhenSuccessCustomResponseThenReturnAccessTokenResponse() {

    WebClientReactiveRefreshTokenTokenResponseClient customClient = new WebClientReactiveRefreshTokenTokenResponseClient();

    BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();

    OAuth2AccessTokenResponse response = TestOAuth2AccessTokenResponses.accessTokenResponse().build();

    given(extractor.extract(any(), any())).willReturn(Mono.just(response));

    customClient.setBodyExtractor(extractor);

    OAuth2RefreshTokenGrantRequest refreshTokenGrantRequest = new OAuth2RefreshTokenGrantRequest(this.clientRegistrationBuilder.build(), this.accessToken, this.refreshToken);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    OAuth2AccessTokenResponse accessTokenResponse = customClient.getTokenResponse(refreshTokenGrantRequest).block();

    assertThat(accessTokenResponse.getAccessToken()).isNotNull();

}

public class MockBodyExtractor {
    public static BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> createMockBodyExtractor(OAuth2AccessTokenResponse response) {
        BodyExtractor<Mono<OAuth2AccessTokenResponse>, ReactiveHttpInputMessage> extractor = mock();
        given(extractor.extract(any(), any())).willReturn(Mono.just(response));
        return extractor;
    }
}

Mock Clone Instance #spring-security_MCI_6

• Scope: method level
• Mocked Class: org.springframework.context.ApplicationEventPublisher
• Test Case Count: 6
• MO Count: 6

Reusable Method

// === Declare in class scope ===
private ApplicationEventPublisher appPublisher;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    appPublisher = mock(ApplicationEventPublisher.class);
}

// === Replace local variable in test with ===
appPublisher

The refactoring details in each test cases

Test Case ID #spring-security_Test_6_1

Test Case Name: expectedDefaultMappingsAreSatisfied(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authentication\DefaultAuthenticationEventPublisherTests.java)

Mock Object Variable Name: appPublisher

@@
 @Test
 public void expectedDefaultMappingsAreSatisfied() {
     this.publisher = new DefaultAuthenticationEventPublisher();
-    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);
+    // removed local mock; replaced with global field `appPublisher`
     this.publisher.setApplicationEventPublisher(appPublisher);
     Authentication a = mock(Authentication.class);
     Exception cause = new Exception();
     Object extraInfo = new Object();
     this.publisher.publishAuthenticationFailure(new BadCredentialsException(""), a);
     this.publisher.publishAuthenticationFailure(new BadCredentialsException("", cause), a);
     verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureBadCredentialsEvent.class));
     reset(appPublisher);
     this.publisher.publishAuthenticationFailure(new UsernameNotFoundException(""), a);
     this.publisher.publishAuthenticationFailure(new UsernameNotFoundException("", cause), a);
     this.publisher.publishAuthenticationFailure(new AccountExpiredException(""), a);
     this.publisher.publishAuthenticationFailure(new AccountExpiredException("", cause), a);
     this.publisher.publishAuthenticationFailure(new ProviderNotFoundException(""), a);
     this.publisher.publishAuthenticationFailure(new DisabledException(""), a);
     this.publisher.publishAuthenticationFailure(new DisabledException("", cause), a);
     this.publisher.publishAuthenticationFailure(new LockedException(""), a);
     this.publisher.publishAuthenticationFailure(new LockedException("", cause), a);
     this.publisher.publishAuthenticationFailure(new AuthenticationServiceException(""), a);
     this.publisher.publishAuthenticationFailure(new AuthenticationServiceException("", cause), a);
     this.publisher.publishAuthenticationFailure(new CredentialsExpiredException(""), a);
     this.publisher.publishAuthenticationFailure(new CredentialsExpiredException("", cause), a);
     verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureBadCredentialsEvent.class));
     verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureExpiredEvent.class));
     verify(appPublisher).publishEvent(isA(AuthenticationFailureProviderNotFoundEvent.class));
     verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureDisabledEvent.class));
     verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureLockedEvent.class));
     verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureServiceExceptionEvent.class));
     verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureCredentialsExpiredEvent.class));
     verifyNoMoreInteractions(appPublisher);
 }

@Test

public void expectedDefaultMappingsAreSatisfied() {

    this.publisher = new DefaultAuthenticationEventPublisher();

    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);

    this.publisher.setApplicationEventPublisher(appPublisher);

    Authentication a = mock(Authentication.class);

    Exception cause = new Exception();

    Object extraInfo = new Object();

    this.publisher.publishAuthenticationFailure(new BadCredentialsException(""), a);

    this.publisher.publishAuthenticationFailure(new BadCredentialsException("", cause), a);

    verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureBadCredentialsEvent.class));

    reset(appPublisher);

    this.publisher.publishAuthenticationFailure(new UsernameNotFoundException(""), a);

    this.publisher.publishAuthenticationFailure(new UsernameNotFoundException("", cause), a);

    this.publisher.publishAuthenticationFailure(new AccountExpiredException(""), a);

    this.publisher.publishAuthenticationFailure(new AccountExpiredException("", cause), a);

    this.publisher.publishAuthenticationFailure(new ProviderNotFoundException(""), a);

    this.publisher.publishAuthenticationFailure(new DisabledException(""), a);

    this.publisher.publishAuthenticationFailure(new DisabledException("", cause), a);

    this.publisher.publishAuthenticationFailure(new LockedException(""), a);

    this.publisher.publishAuthenticationFailure(new LockedException("", cause), a);

    this.publisher.publishAuthenticationFailure(new AuthenticationServiceException(""), a);

    this.publisher.publishAuthenticationFailure(new AuthenticationServiceException("", cause), a);

    this.publisher.publishAuthenticationFailure(new CredentialsExpiredException(""), a);

    this.publisher.publishAuthenticationFailure(new CredentialsExpiredException("", cause), a);

    verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureBadCredentialsEvent.class));

    verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureExpiredEvent.class));

    verify(appPublisher).publishEvent(isA(AuthenticationFailureProviderNotFoundEvent.class));

    verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureDisabledEvent.class));

    verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureLockedEvent.class));

    verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureServiceExceptionEvent.class));

    verify(appPublisher, times(2)).publishEvent(isA(AuthenticationFailureCredentialsExpiredEvent.class));

    verifyNoMoreInteractions(appPublisher);

}

// === Declare in class scope ===
private ApplicationEventPublisher appPublisher;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    appPublisher = mock(ApplicationEventPublisher.class);
}

// === Replace local variable in test with ===
appPublisher

Test Case ID #spring-security_Test_6_2

Test Case Name: authenticationSuccessIsPublished(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authentication\DefaultAuthenticationEventPublisherTests.java)

Mock Object Variable Name: appPublisher

@@
 @Test
 public void authenticationSuccessIsPublished() {
     this.publisher = new DefaultAuthenticationEventPublisher();
-    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);
+    // removed local mock; replaced with global field `appPublisher`
     this.publisher.setApplicationEventPublisher(appPublisher);
     this.publisher.publishAuthenticationSuccess(mock(Authentication.class));
-    verify(appPublisher).publishEvent(isA(AuthenticationSuccessEvent.class));
+    verify(appPublisher).publishEvent(isA(AuthenticationSuccessEvent.class));
     this.publisher.setApplicationEventPublisher(null);
     // Should be ignored with null app publisher
     this.publisher.publishAuthenticationSuccess(mock(Authentication.class));
 }

@Test

public void authenticationSuccessIsPublished() {

    this.publisher = new DefaultAuthenticationEventPublisher();

    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);

    this.publisher.setApplicationEventPublisher(appPublisher);

    this.publisher.publishAuthenticationSuccess(mock(Authentication.class));

    verify(appPublisher).publishEvent(isA(AuthenticationSuccessEvent.class));

    this.publisher.setApplicationEventPublisher(null);

    // Should be ignored with null app publisher

    this.publisher.publishAuthenticationSuccess(mock(Authentication.class));

}

// === Declare in class scope ===
private ApplicationEventPublisher appPublisher;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    appPublisher = mock(ApplicationEventPublisher.class);
}

// === Replace local variable in test with ===
appPublisher

Test Case ID #spring-security_Test_6_3

Test Case Name: additionalExceptionMappingsAreSupported(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authentication\DefaultAuthenticationEventPublisherTests.java)

Mock Object Variable Name: appPublisher

@@
 @Test
 public void additionalExceptionMappingsAreSupported() {
     this.publisher = new DefaultAuthenticationEventPublisher();
     Properties p = new Properties();
     p.put(MockAuthenticationException.class.getName(), AuthenticationFailureDisabledEvent.class.getName());
     this.publisher.setAdditionalExceptionMappings(p);
-    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);
+    // removed local mock; replaced with global field `appPublisher`
     this.publisher.setApplicationEventPublisher(appPublisher);
     this.publisher.publishAuthenticationFailure(new MockAuthenticationException("test"), mock(Authentication.class));
     verify(appPublisher).publishEvent(isA(AuthenticationFailureDisabledEvent.class));
}

@Test

public void additionalExceptionMappingsAreSupported() {

    this.publisher = new DefaultAuthenticationEventPublisher();

    Properties p = new Properties();

    p.put(MockAuthenticationException.class.getName(), AuthenticationFailureDisabledEvent.class.getName());

    this.publisher.setAdditionalExceptionMappings(p);

    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);

    this.publisher.setApplicationEventPublisher(appPublisher);

    this.publisher.publishAuthenticationFailure(new MockAuthenticationException("test"), mock(Authentication.class));

    verify(appPublisher).publishEvent(isA(AuthenticationFailureDisabledEvent.class));

}

// === Declare in class scope ===
private ApplicationEventPublisher appPublisher;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    appPublisher = mock(ApplicationEventPublisher.class);
}

// === Replace local variable in test with ===
appPublisher

Test Case ID #spring-security_Test_6_4

Test Case Name: unknownFailureExceptionIsIgnored(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authentication\DefaultAuthenticationEventPublisherTests.java)

Mock Object Variable Name: appPublisher

@@
 @Test
 public void unknownFailureExceptionIsIgnored() {
     this.publisher = new DefaultAuthenticationEventPublisher();
     Properties p = new Properties();
     p.put(MockAuthenticationException.class.getName(), AuthenticationFailureDisabledEvent.class.getName());
     this.publisher.setAdditionalExceptionMappings(p);
-    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);
+    // removed local mock; replaced with global field `appPublisher`
     this.publisher.setApplicationEventPublisher(appPublisher);
     this.publisher.publishAuthenticationFailure(new AuthenticationException("") {
     }, mock(Authentication.class));
     verifyNoMoreInteractions(appPublisher);
}

@Test

public void unknownFailureExceptionIsIgnored() {

    this.publisher = new DefaultAuthenticationEventPublisher();

    Properties p = new Properties();

    p.put(MockAuthenticationException.class.getName(), AuthenticationFailureDisabledEvent.class.getName());

    this.publisher.setAdditionalExceptionMappings(p);

    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);

    this.publisher.setApplicationEventPublisher(appPublisher);

    this.publisher.publishAuthenticationFailure(new AuthenticationException("") {

    }, mock(Authentication.class));

    verifyNoMoreInteractions(appPublisher);

}

// === Declare in class scope ===
private ApplicationEventPublisher appPublisher;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    appPublisher = mock(ApplicationEventPublisher.class);
}

// === Replace local variable in test with ===
appPublisher

Test Case ID #spring-security_Test_6_5

Test Case Name: additionalExceptionMappingsUsingMapAreSupported(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authentication\DefaultAuthenticationEventPublisherTests.java)

Mock Object Variable Name: appPublisher

@@
     this.publisher.setAdditionalExceptionMappings(mappings);
-    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);
+    // removed local mock; replaced with global field `appPublisher`
     this.publisher.setApplicationEventPublisher(appPublisher);
     this.publisher.publishAuthenticationFailure(new MockAuthenticationException("test"), mock(Authentication.class));
-    verify(appPublisher).publishEvent(isA(AuthenticationFailureDisabledEvent.class));
+    verify(appPublisher).publishEvent(isA(AuthenticationFailureDisabledEvent.class));

@Test

public void additionalExceptionMappingsUsingMapAreSupported() {

    this.publisher = new DefaultAuthenticationEventPublisher();

    Map<Class<? extends AuthenticationException>, Class<? extends AbstractAuthenticationFailureEvent>> mappings = new HashMap<>();

    mappings.put(MockAuthenticationException.class, AuthenticationFailureDisabledEvent.class);

    this.publisher.setAdditionalExceptionMappings(mappings);

    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);

    this.publisher.setApplicationEventPublisher(appPublisher);

    this.publisher.publishAuthenticationFailure(new MockAuthenticationException("test"), mock(Authentication.class));

    verify(appPublisher).publishEvent(isA(AuthenticationFailureDisabledEvent.class));

}

// === Declare in class scope ===
private ApplicationEventPublisher appPublisher;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    appPublisher = mock(ApplicationEventPublisher.class);
}

// === Replace local variable in test with ===
appPublisher

Test Case ID #spring-security_Test_6_6

Test Case Name: defaultAuthenticationFailureEventIsPublished(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authentication\DefaultAuthenticationEventPublisherTests.java)

Mock Object Variable Name: appPublisher

@@
 @Test
 public void defaultAuthenticationFailureEventIsPublished() {
     this.publisher = new DefaultAuthenticationEventPublisher();
     this.publisher.setDefaultAuthenticationFailureEvent(AuthenticationFailureBadCredentialsEvent.class);
-    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);
+    // removed local mock; replaced with global field `appPublisher`
     this.publisher.setApplicationEventPublisher(appPublisher);
     this.publisher.publishAuthenticationFailure(new AuthenticationException("") {
     }, mock(Authentication.class));
-    verify(appPublisher).publishEvent(isA(AuthenticationFailureBadCredentialsEvent.class));
+    verify(appPublisher).publishEvent(isA(AuthenticationFailureBadCredentialsEvent.class));
 }

@Test

public void defaultAuthenticationFailureEventIsPublished() {

    this.publisher = new DefaultAuthenticationEventPublisher();

    this.publisher.setDefaultAuthenticationFailureEvent(AuthenticationFailureBadCredentialsEvent.class);

    ApplicationEventPublisher appPublisher = mock(ApplicationEventPublisher.class);

    this.publisher.setApplicationEventPublisher(appPublisher);

    this.publisher.publishAuthenticationFailure(new AuthenticationException("") {

    }, mock(Authentication.class));

    verify(appPublisher).publishEvent(isA(AuthenticationFailureBadCredentialsEvent.class));

}

// === Declare in class scope ===
private ApplicationEventPublisher appPublisher;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    appPublisher = mock(ApplicationEventPublisher.class);
}

// === Replace local variable in test with ===
appPublisher

Mock Clone Instance #spring-security_MCI_7

• Scope: method level
• Mocked Class: io.micrometer.observation.ObservationHandler<?>
• Test Case Count: 5
• MO Count: 5

Reusable Method

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_7_1

Test Case Name: decorateWhenDefaultsThenObserves(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\ObservationFilterChainDecoratorTests.java)

Mock Object Variable Name: handler

--- original
+++ refactored
@@
void decorateWhenDefaultsThenObserves() throws Exception {
-    ObservationHandler<?> handler = mock(ObservationHandler.class);
-    given(handler.supportsContext(any())).willReturn(true);
+    ObservationHandler<?> handler = createMockObservationHandler();
    ObservationRegistry registry = ObservationRegistry.create();
    registry.observationConfig().observationHandler(handler);
    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);
    FilterChain chain = mock(FilterChain.class);
    FilterChain decorated = decorator.decorate(chain);
    decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());
    verify(handler).onStart(any());
}

@Test

void decorateWhenDefaultsThenObserves() throws Exception {

    ObservationHandler<?> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.create();

    registry.observationConfig().observationHandler(handler);

    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);

    FilterChain chain = mock(FilterChain.class);

    FilterChain decorated = decorator.decorate(chain);

    decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());

    verify(handler).onStart(any());

}

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

Test Case ID #spring-security_Test_7_2

Test Case Name: decorateWhenNoopThenDoesNotObserve(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\ObservationFilterChainDecoratorTests.java)

Mock Object Variable Name: handler

@@
 @Test
 void decorateWhenNoopThenDoesNotObserve() throws Exception {
-    ObservationHandler<?> handler = mock(ObservationHandler.class);
-    given(handler.supportsContext(any())).willReturn(true);
+    ObservationHandler<?> handler = createMockObservationHandler();
     ObservationRegistry registry = ObservationRegistry.NOOP;
     registry.observationConfig().observationHandler(handler);
     ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);
     FilterChain chain = mock(FilterChain.class);
     FilterChain decorated = decorator.decorate(chain);
     decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());
     verifyNoInteractions(handler);
 }
@@

@Test

void decorateWhenNoopThenDoesNotObserve() throws Exception {

    ObservationHandler<?> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.NOOP;

    registry.observationConfig().observationHandler(handler);

    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);

    FilterChain chain = mock(FilterChain.class);

    FilterChain decorated = decorator.decorate(chain);

    decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());

    verifyNoInteractions(handler);

}

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

Test Case ID #spring-security_Test_7_3

Test Case Name: decorateFiltersWhenDefaultsThenObserves(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\ObservationFilterChainDecoratorTests.java)

Mock Object Variable Name: handler

--- original
+++ refactored
@@
void decorateFiltersWhenDefaultsThenObserves() throws Exception {
-    ObservationHandler<?> handler = mock(ObservationHandler.class);
-    given(handler.supportsContext(any())).willReturn(true);
+    ObservationHandler<?> handler = createMockObservationHandler();
    ObservationRegistry registry = ObservationRegistry.create();
    registry.observationConfig().observationHandler(handler);
    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);
    FilterChain chain = mock(FilterChain.class);
    Filter filter = mock(Filter.class);
    FilterChain decorated = decorator.decorate(chain, List.of(filter));
    decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());
    verify(handler, times(2)).onStart(any());
    ArgumentCaptor<Observation.Event> event = ArgumentCaptor.forClass(Observation.Event.class);
    verify(handler, times(2)).onEvent(event.capture(), any());
    List<Observation.Event> events = event.getAllValues();
    assertThat(events.get(0).getName()).isEqualTo(filter.getClass().getSimpleName() + ".before");
    assertThat(events.get(1).getName()).isEqualTo(filter.getClass().getSimpleName() + ".after");
}

@Test

void decorateFiltersWhenDefaultsThenObserves() throws Exception {

    ObservationHandler<?> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.create();

    registry.observationConfig().observationHandler(handler);

    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);

    FilterChain chain = mock(FilterChain.class);

    Filter filter = mock(Filter.class);

    FilterChain decorated = decorator.decorate(chain, List.of(filter));

    decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());

    verify(handler, times(2)).onStart(any());

    ArgumentCaptor<Observation.Event> event = ArgumentCaptor.forClass(Observation.Event.class);

    verify(handler, times(2)).onEvent(event.capture(), any());

    List<Observation.Event> events = event.getAllValues();

    assertThat(events.get(0).getName()).isEqualTo(filter.getClass().getSimpleName() + ".before");

    assertThat(events.get(1).getName()).isEqualTo(filter.getClass().getSimpleName() + ".after");

}

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

Test Case ID #spring-security_Test_7_4

Test Case Name: decorateFiltersWhenDefaultsThenUsesEventName(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\ObservationFilterChainDecoratorTests.java)

Mock Object Variable Name: handler

--- original
+++ refactored
@@
void decorateFiltersWhenDefaultsThenUsesEventName() throws Exception {
-    ObservationHandler<?> handler = mock(ObservationHandler.class);
-    given(handler.supportsContext(any())).willReturn(true);
+    ObservationHandler<?> handler = createMockObservationHandler();
    ObservationRegistry registry = ObservationRegistry.create();
    registry.observationConfig().observationHandler(handler);
    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);
    FilterChain chain = mock(FilterChain.class);
    Filter filter = new BasicAuthenticationFilter();
    FilterChain decorated = decorator.decorate(chain, List.of(filter));
    decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());
    ArgumentCaptor<Observation.Event> event = ArgumentCaptor.forClass(Observation.Event.class);
    verify(handler, times(2)).onEvent(event.capture(), any());
    List<Observation.Event> events = event.getAllValues();
    assertThat(events.get(0).getName()).isEqualTo("authentication.basic.before");
    assertThat(events.get(1).getName()).isEqualTo("authentication.basic.after");
}

@Test

void decorateFiltersWhenDefaultsThenUsesEventName() throws Exception {

    ObservationHandler<?> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.create();

    registry.observationConfig().observationHandler(handler);

    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);

    FilterChain chain = mock(FilterChain.class);

    Filter filter = new BasicAuthenticationFilter();

    FilterChain decorated = decorator.decorate(chain, List.of(filter));

    decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse());

    ArgumentCaptor<Observation.Event> event = ArgumentCaptor.forClass(Observation.Event.class);

    verify(handler, times(2)).onEvent(event.capture(), any());

    List<Observation.Event> events = event.getAllValues();

    assertThat(events.get(0).getName()).isEqualTo("authentication.basic.before");

    assertThat(events.get(1).getName()).isEqualTo("authentication.basic.after");

}

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

Test Case ID #spring-security_Test_7_5

Test Case Name: decorateFiltersWhenErrorsThenClosesObservationOnlyOnce(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\ObservationFilterChainDecoratorTests.java)

Mock Object Variable Name: handler

--- original
+++ refactored
@@
void decorateFiltersWhenErrorsThenClosesObservationOnlyOnce() throws Exception {
-    ObservationHandler<?> handler = mock(ObservationHandler.class);
-    given(handler.supportsContext(any())).willReturn(true);
+    ObservationHandler<?> handler = createMockObservationHandler();
    ObservationRegistry registry = ObservationRegistry.create();
    registry.observationConfig().observationHandler(handler);
    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);
    FilterChain chain = mock(FilterChain.class);
    Filter filter = mock(Filter.class);
    willThrow(IllegalArgumentException.class).given(filter).doFilter(any(), any(), any());
    FilterChain decorated = decorator.decorate(chain, List.of(filter));
    assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse()));
    verify(handler).onScopeClosed(any());
}

// gh-12787

@Test

void decorateFiltersWhenErrorsThenClosesObservationOnlyOnce() throws Exception {

    ObservationHandler<?> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.create();

    registry.observationConfig().observationHandler(handler);

    ObservationFilterChainDecorator decorator = new ObservationFilterChainDecorator(registry);

    FilterChain chain = mock(FilterChain.class);

    Filter filter = mock(Filter.class);

    willThrow(IllegalArgumentException.class).given(filter).doFilter(any(), any(), any());

    FilterChain decorated = decorator.decorate(chain, List.of(filter));

    assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> decorated.doFilter(new MockHttpServletRequest("GET", "/"), new MockHttpServletResponse()));

    verify(handler).onScopeClosed(any());

}

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

Mock Clone Instance #spring-security_MCI_8

• Scope: method level
• Mocked Class: io.micrometer.observation.ObservationHandler<?>
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_8_1

Test Case Name: decorateWhenDefaultsThenObserves(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\server\ObservationWebFilterChainDecoratorTests.java)

Mock Object Variable Name: handler

@@
 @Test
 void decorateWhenDefaultsThenObserves() {
-    ObservationHandler<?> handler = mock(ObservationHandler.class);
-    given(handler.supportsContext(any())).willReturn(true);
+    ObservationHandler<?> handler = createMockObservationHandler();
     ObservationRegistry registry = ObservationRegistry.create();
     registry.observationConfig().observationHandler(handler);
     ObservationWebFilterChainDecorator decorator = new ObservationWebFilterChainDecorator(registry);
     WebFilterChain chain = mock(WebFilterChain.class);
     given(chain.filter(any())).willReturn(Mono.empty());
     WebFilterChain decorated = decorator.decorate(chain);
     decorated.filter(MockServerWebExchange.from(MockServerHttpRequest.get("/").build())).block();
     verify(handler).onStart(any());
 }
@@

@Test

void decorateWhenDefaultsThenObserves() {

    ObservationHandler<?> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.create();

    registry.observationConfig().observationHandler(handler);

    ObservationWebFilterChainDecorator decorator = new ObservationWebFilterChainDecorator(registry);

    WebFilterChain chain = mock(WebFilterChain.class);

    given(chain.filter(any())).willReturn(Mono.empty());

    WebFilterChain decorated = decorator.decorate(chain);

    decorated.filter(MockServerWebExchange.from(MockServerHttpRequest.get("/").build())).block();

    verify(handler).onStart(any());

}

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

Test Case ID #spring-security_Test_8_2

Test Case Name: decorateWhenNoopThenDoesNotObserve(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\server\ObservationWebFilterChainDecoratorTests.java)

Mock Object Variable Name: handler

--- original
+++ refactored
@@
void decorateWhenNoopThenDoesNotObserve() {
-    ObservationHandler<?> handler = mock(ObservationHandler.class);
-    given(handler.supportsContext(any())).willReturn(true);
+    ObservationHandler<?> handler = createMockObservationHandler();
    ObservationRegistry registry = ObservationRegistry.NOOP;
    registry.observationConfig().observationHandler(handler);
    ObservationWebFilterChainDecorator decorator = new ObservationWebFilterChainDecorator(registry);
    WebFilterChain chain = mock(WebFilterChain.class);
    given(chain.filter(any())).willReturn(Mono.empty());
    WebFilterChain decorated = decorator.decorate(chain);
    decorated.filter(MockServerWebExchange.from(MockServerHttpRequest.get("/").build())).block();
    verifyNoInteractions(handler);
}

@Test

void decorateWhenNoopThenDoesNotObserve() {

    ObservationHandler<?> handler = mock(ObservationHandler.class);

    given(handler.supportsContext(any())).willReturn(true);

    ObservationRegistry registry = ObservationRegistry.NOOP;

    registry.observationConfig().observationHandler(handler);

    ObservationWebFilterChainDecorator decorator = new ObservationWebFilterChainDecorator(registry);

    WebFilterChain chain = mock(WebFilterChain.class);

    given(chain.filter(any())).willReturn(Mono.empty());

    WebFilterChain decorated = decorator.decorate(chain);

    decorated.filter(MockServerWebExchange.from(MockServerHttpRequest.get("/").build())).block();

    verifyNoInteractions(handler);

}

private static ObservationHandler<?> createMockObservationHandler() {
    ObservationHandler<?> handler = mock(ObservationHandler.class);
    given(handler.supportsContext(any())).willReturn(true);
    return handler;
}

Mock Clone Instance #spring-security_MCI_9

• Scope: method level
• Mocked Class: org.springframework.test.context.TestContext
• Test Case Count: 4
• MO Count: 4

Reusable Method

private static TestContext createMockTestContext(Method testMethod) {
    TestContext testContext = mock(TestContext.class);
    given(testContext.getTestMethod()).willReturn(testMethod);
    given(testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
    return testContext;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_9_1

Test Case Name: handlesGenericAnnotation(File: C:\Java_projects\Spring\spring-security\test\src\test\java\org\springframework\security\test\context\support\WithSecurityContextTestExcecutionListenerTests.java)

Mock Object Variable Name: testContext

@@
     Method method = ReflectionUtils.findMethod(WithSecurityContextTestExcecutionListenerTests.class, "handlesGenericAnnotationTestMethod");
-    TestContext testContext = mock(TestContext.class);
-    given(testContext.getTestMethod()).willReturn(method);
-    given(testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
+    TestContext testContext = createMockTestContext(method);
    this.listener.beforeTestMethod(testContext);
    assertThat(SecurityContextHolder.getContext().getAuthentication().getPrincipal()).isInstanceOf(WithSuperClassWithSecurityContext.class);
}

@Test

public // gh-3837

void handlesGenericAnnotation() throws Exception {

    Method method = ReflectionUtils.findMethod(WithSecurityContextTestExcecutionListenerTests.class, "handlesGenericAnnotationTestMethod");

    TestContext testContext = mock(TestContext.class);

    given(testContext.getTestMethod()).willReturn(method);

    given(testContext.getApplicationContext()).willThrow(new IllegalStateException(""));

    this.listener.beforeTestMethod(testContext);

    assertThat(SecurityContextHolder.getContext().getAuthentication().getPrincipal()).isInstanceOf(WithSuperClassWithSecurityContext.class);

}

private static TestContext createMockTestContext(Method testMethod) {
    TestContext testContext = mock(TestContext.class);
    given(testContext.getTestMethod()).willReturn(testMethod);
    given(testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
    return testContext;
}

Test Case ID #spring-security_Test_9_2

Test Case Name: beforeTestMethodNoApplicationContext(File: C:\Java_projects\Spring\spring-security\test\src\test\java\org\springframework\security\test\context\support\WithSecurityContextTestExcecutionListenerTests.java)

Mock Object Variable Name: testContext

@@
     Class testClass = FakeTest.class;
-    given(this.testContext.getApplicationContext()).willThrow(new IllegalStateException());
-    given(this.testContext.getTestMethod()).willReturn(ReflectionUtils.findMethod(testClass, "testWithMockUser"));
+    this.testContext = createMockTestContext(ReflectionUtils.findMethod(testClass, "testWithMockUser"));
     this.listener.beforeTestMethod(this.testContext);
     assertThat(TestSecurityContextHolder.getContext().getAuthentication().getName()).isEqualTo("user");
 }

@Test

@SuppressWarnings({ "rawtypes", "unchecked" })

public void beforeTestMethodNoApplicationContext() throws Exception {

    Class testClass = FakeTest.class;

    given(this.testContext.getApplicationContext()).willThrow(new IllegalStateException());

    given(this.testContext.getTestMethod()).willReturn(ReflectionUtils.findMethod(testClass, "testWithMockUser"));

    this.listener.beforeTestMethod(this.testContext);

    assertThat(TestSecurityContextHolder.getContext().getAuthentication().getName()).isEqualTo("user");

}

private static TestContext createMockTestContext(Method testMethod) {
    TestContext testContext = mock(TestContext.class);
    given(testContext.getTestMethod()).willReturn(testMethod);
    given(testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
    return testContext;
}

Test Case ID #spring-security_Test_9_3

Test Case Name: beforeTestMethodInnerClass(File: C:\Java_projects\Spring\spring-security\test\src\test\java\org\springframework\security\test\context\support\WithSecurityContextTestExcecutionListenerTests.java)

Mock Object Variable Name: testContext

@@
     Class testClass = OuterClass.InnerClass.class;
     Method testNoAnnotation = ReflectionUtils.findMethod(testClass, "testNoAnnotation");
-    given(this.testContext.getTestClass()).willReturn(testClass);
-    given(this.testContext.getTestMethod()).willReturn(testNoAnnotation);
-    given(this.testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
+    this.testContext = createMockTestContext(testNoAnnotation);
+    given(this.testContext.getTestClass()).willReturn(testClass);
     this.listener.beforeTestMethod(this.testContext);
     assertThat(TestSecurityContextHolder.getContext().getAuthentication().getName()).isEqualTo("user");
 }
@@

@Test

@SuppressWarnings({ "rawtypes", "unchecked" })

public void beforeTestMethodInnerClass() throws Exception {

    Class testClass = OuterClass.InnerClass.class;

    Method testNoAnnotation = ReflectionUtils.findMethod(testClass, "testNoAnnotation");

    given(this.testContext.getTestClass()).willReturn(testClass);

    given(this.testContext.getTestMethod()).willReturn(testNoAnnotation);

    given(this.testContext.getApplicationContext()).willThrow(new IllegalStateException(""));

    this.listener.beforeTestMethod(this.testContext);

    assertThat(TestSecurityContextHolder.getContext().getAuthentication().getName()).isEqualTo("user");

}

private static TestContext createMockTestContext(Method testMethod) {
    TestContext testContext = mock(TestContext.class);
    given(testContext.getTestMethod()).willReturn(testMethod);
    given(testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
    return testContext;
}

Test Case ID #spring-security_Test_9_4

Test Case Name: beforeTestMethodInnerInnerClass(File: C:\Java_projects\Spring\spring-security\test\src\test\java\org\springframework\security\test\context\support\WithSecurityContextTestExcecutionListenerTests.java)

Mock Object Variable Name: testContext

@@
     Class testClass = OuterClass.InnerClass.InnerInnerClass.class;
     Method testNoAnnotation = ReflectionUtils.findMethod(testClass, "testNoAnnotation");
-    given(this.testContext.getTestClass()).willReturn(testClass);
-    given(this.testContext.getTestMethod()).willReturn(testNoAnnotation);
-    given(this.testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
+    this.testContext = createMockTestContext(testNoAnnotation);
+    given(this.testContext.getTestClass()).willReturn(testClass);
     this.listener.beforeTestMethod(this.testContext);
     assertThat(TestSecurityContextHolder.getContext().getAuthentication().getName()).isEqualTo("user");
 }
@@

@Test

@SuppressWarnings({ "rawtypes", "unchecked" })

public void beforeTestMethodInnerInnerClass() throws Exception {

    Class testClass = OuterClass.InnerClass.InnerInnerClass.class;

    Method testNoAnnotation = ReflectionUtils.findMethod(testClass, "testNoAnnotation");

    given(this.testContext.getTestClass()).willReturn(testClass);

    given(this.testContext.getTestMethod()).willReturn(testNoAnnotation);

    given(this.testContext.getApplicationContext()).willThrow(new IllegalStateException(""));

    this.listener.beforeTestMethod(this.testContext);

    assertThat(TestSecurityContextHolder.getContext().getAuthentication().getName()).isEqualTo("user");

}

private static TestContext createMockTestContext(Method testMethod) {
    TestContext testContext = mock(TestContext.class);
    given(testContext.getTestMethod()).willReturn(testMethod);
    given(testContext.getApplicationContext()).willThrow(new IllegalStateException(""));
    return testContext;
}

Mock Clone Instance #spring-security_MCI_10

• Scope: class level
• Mocked Class: org.springframework.web.client.RestClient
• Test Case Count: 1
• MO Count: 2

Reusable Method

public class MockRestClient {
    public static RestClient createMockRestClient(RestClient.RequestBodyUriSpec postReturn) {
        RestClient mockRestClient = mock();
        given(mockRestClient.post()).willReturn(postReturn);
        return mockRestClient;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_10_1

Test Case Name: getTokenResponseWhenRestClientSetThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\RestClientJwtBearerTokenResponseClientTests.java)

Mock Object Variable Name: customClient

@@
     this.server.enqueue(MockResponses.json("access-token-response.json"));
-    RestClient customClient = mock();
-    given(customClient.post()).willReturn(RestClient.builder().build().post());
+    RestClient customClient = MockRestClient.createMockRestClient(RestClient.builder().build().post());
     this.tokenResponseClient.setRestClient(customClient);
     ClientRegistration clientRegistration = this.clientRegistration.build();
     JwtBearerGrantRequest grantRequest = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);
     this.tokenResponseClient.getTokenResponse(grantRequest);
     verify(customClient).post();
@@

@Test

public void getTokenResponseWhenRestClientSetThenCalled() {

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    RestClient customClient = mock();

    given(customClient.post()).willReturn(RestClient.builder().build().post());

    this.tokenResponseClient.setRestClient(customClient);

    ClientRegistration clientRegistration = this.clientRegistration.build();

    JwtBearerGrantRequest grantRequest = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);

    this.tokenResponseClient.getTokenResponse(grantRequest);

    verify(customClient).post();

}

public class MockRestClient {
    public static RestClient createMockRestClient(RestClient.RequestBodyUriSpec postReturn) {
        RestClient mockRestClient = mock();
        given(mockRestClient.post()).willReturn(postReturn);
        return mockRestClient;
    }
}

Test Case ID #spring-security_Test_10_2

Test Case Name: getTokenResponseWhenRestClientSetThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\RestClientTokenExchangeTokenResponseClientTests.java)

Mock Object Variable Name: customClient

@@
     this.server.enqueue(MockResponses.json("access-token-response.json"));
-    RestClient customClient = mock();
-    given(customClient.post()).willReturn(RestClient.builder().build().post());
+    RestClient customClient = MockRestClient.createMockRestClient(RestClient.builder().build().post());
     this.tokenResponseClient.setRestClient(customClient);
     ClientRegistration clientRegistration = this.clientRegistration.build();
     TokenExchangeGrantRequest grantRequest = new TokenExchangeGrantRequest(clientRegistration, this.subjectToken, this.actorToken);
     this.tokenResponseClient.getTokenResponse(grantRequest);
     verify(customClient).post();
 }
@@

@Test

public void getTokenResponseWhenRestClientSetThenCalled() {

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    RestClient customClient = mock();

    given(customClient.post()).willReturn(RestClient.builder().build().post());

    this.tokenResponseClient.setRestClient(customClient);

    ClientRegistration clientRegistration = this.clientRegistration.build();

    TokenExchangeGrantRequest grantRequest = new TokenExchangeGrantRequest(clientRegistration, this.subjectToken, this.actorToken);

    this.tokenResponseClient.getTokenResponse(grantRequest);

    verify(customClient).post();

}

public class MockRestClient {
    public static RestClient createMockRestClient(RestClient.RequestBodyUriSpec postReturn) {
        RestClient mockRestClient = mock();
        given(mockRestClient.post()).willReturn(postReturn);
        return mockRestClient;
    }
}

Mock Clone Instance #spring-security_MCI_11

• Scope: class level
• Mocked Class: org.springframework.core.convert.converter.Converter<org.springframework.security.oauth2.client.endpoint.JwtBearerGrantRequest, org.springframework.http.HttpHeaders>
• Test Case Count: 2
• MO Count: 4

Reusable Method

public class MockConverter {
    public static Converter<JwtBearerGrantRequest, HttpHeaders> createMockHeadersConverter(JwtBearerGrantRequest request, HttpHeaders headers) {
        Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
        given(headersConverter.convert(request)).willReturn(headers);
        return headersConverter;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_11_1

Test Case Name: getTokenResponseWhenHeadersConverterAddedThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\RestClientJwtBearerTokenResponseClientTests.java)

Mock Object Variable Name: headersConverter

--- original
+++ refactored
@@
    ClientRegistration clientRegistration = this.clientRegistration.build();
    JwtBearerGrantRequest grantRequest = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);
-    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
    HttpHeaders headers = new HttpHeaders();
    headers.put("custom-header-name", Collections.singletonList("custom-header-value"));
-    given(headersConverter.convert(grantRequest)).willReturn(headers);
+    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = MockConverter.createMockHeadersConverter(grantRequest, headers);
    this.tokenResponseClient.addHeadersConverter(headersConverter);
    this.tokenResponseClient.getTokenResponse(grantRequest);
    verify(headersConverter).convert(grantRequest);
    RecordedRequest recordedRequest = this.server.takeRequest();
    assertThat(recordedRequest.getHeader(HttpHeaders.AUTHORIZATION)).startsWith("Basic ");
    assertThat(recordedRequest.getHeader("custom-header-name")).isEqualTo("custom-header-value");
@@

@Test

public void getTokenResponseWhenHeadersConverterAddedThenCalled() throws Exception {

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    ClientRegistration clientRegistration = this.clientRegistration.build();

    JwtBearerGrantRequest grantRequest = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);

    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();

    HttpHeaders headers = new HttpHeaders();

    headers.put("custom-header-name", Collections.singletonList("custom-header-value"));

    given(headersConverter.convert(grantRequest)).willReturn(headers);

    this.tokenResponseClient.addHeadersConverter(headersConverter);

    this.tokenResponseClient.getTokenResponse(grantRequest);

    verify(headersConverter).convert(grantRequest);

    RecordedRequest recordedRequest = this.server.takeRequest();

    assertThat(recordedRequest.getHeader(HttpHeaders.AUTHORIZATION)).startsWith("Basic ");

    assertThat(recordedRequest.getHeader("custom-header-name")).isEqualTo("custom-header-value");

}

public class MockConverter {
    public static Converter<JwtBearerGrantRequest, HttpHeaders> createMockHeadersConverter(JwtBearerGrantRequest request, HttpHeaders headers) {
        Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
        given(headersConverter.convert(request)).willReturn(headers);
        return headersConverter;
    }
}

Test Case ID #spring-security_Test_11_2

Test Case Name: getTokenResponseWhenHeadersConverterSetThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\RestClientJwtBearerTokenResponseClientTests.java)

Mock Object Variable Name: headersConverter

--- original
+++ refactored
@@
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    ClientRegistration clientRegistration = this.clientRegistration.build();
    JwtBearerGrantRequest grantRequest = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);
-    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
    HttpHeaders headers = new HttpHeaders();
    headers.put("custom-header-name", Collections.singletonList("custom-header-value"));
-    given(headersConverter.convert(grantRequest)).willReturn(headers);
+    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = MockConverter.createMockHeadersConverter(grantRequest, headers);
    this.tokenResponseClient.setHeadersConverter(headersConverter);
    this.tokenResponseClient.getTokenResponse(grantRequest);
    verify(headersConverter).convert(grantRequest);
    RecordedRequest recordedRequest = this.server.takeRequest();
    assertThat(recordedRequest.getHeader(HttpHeaders.AUTHORIZATION)).isNull();
    assertThat(recordedRequest.getHeader("custom-header-name")).isEqualTo("custom-header-value");
@@

@Test

public void getTokenResponseWhenHeadersConverterSetThenCalled() throws Exception {

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    ClientRegistration clientRegistration = this.clientRegistration.build();

    JwtBearerGrantRequest grantRequest = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);

    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();

    HttpHeaders headers = new HttpHeaders();

    headers.put("custom-header-name", Collections.singletonList("custom-header-value"));

    given(headersConverter.convert(grantRequest)).willReturn(headers);

    this.tokenResponseClient.setHeadersConverter(headersConverter);

    this.tokenResponseClient.getTokenResponse(grantRequest);

    verify(headersConverter).convert(grantRequest);

    RecordedRequest recordedRequest = this.server.takeRequest();

    assertThat(recordedRequest.getHeader(HttpHeaders.AUTHORIZATION)).isNull();

    assertThat(recordedRequest.getHeader("custom-header-name")).isEqualTo("custom-header-value");

}

public class MockConverter {
    public static Converter<JwtBearerGrantRequest, HttpHeaders> createMockHeadersConverter(JwtBearerGrantRequest request, HttpHeaders headers) {
        Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
        given(headersConverter.convert(request)).willReturn(headers);
        return headersConverter;
    }
}

Test Case ID #spring-security_Test_11_3

Test Case Name: getTokenResponseWhenHeadersConverterSetThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactiveJwtBearerTokenResponseClientTests.java)

Mock Object Variable Name: headersConverter

--- original
+++ refactored
@@
    ClientRegistration clientRegistration = this.clientRegistration.build();
    JwtBearerGrantRequest request = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);
-    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
    HttpHeaders headers = new HttpHeaders();
    headers.setBasicAuth(clientRegistration.getClientId(), clientRegistration.getClientSecret());
-    given(headersConverter.convert(request)).willReturn(headers);
+    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = MockConverter.createMockHeadersConverter(request, headers);
    this.client.setHeadersConverter(headersConverter);
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    this.client.getTokenResponse(request).block();
    verify(headersConverter).convert(request);
    RecordedRequest actualRequest = this.server.takeRequest();
    assertThat(actualRequest.getHeader(HttpHeaders.AUTHORIZATION)).isEqualTo("Basic Y2xpZW50LWlkOmNsaWVudC1zZWNyZXQ=");
@@

@Test

public void getTokenResponseWhenHeadersConverterSetThenCalled() throws Exception {

    ClientRegistration clientRegistration = this.clientRegistration.build();

    JwtBearerGrantRequest request = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);

    Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();

    HttpHeaders headers = new HttpHeaders();

    headers.setBasicAuth(clientRegistration.getClientId(), clientRegistration.getClientSecret());

    given(headersConverter.convert(request)).willReturn(headers);

    this.client.setHeadersConverter(headersConverter);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    this.client.getTokenResponse(request).block();

    verify(headersConverter).convert(request);

    RecordedRequest actualRequest = this.server.takeRequest();

    assertThat(actualRequest.getHeader(HttpHeaders.AUTHORIZATION)).isEqualTo("Basic Y2xpZW50LWlkOmNsaWVudC1zZWNyZXQ=");

}

public class MockConverter {
    public static Converter<JwtBearerGrantRequest, HttpHeaders> createMockHeadersConverter(JwtBearerGrantRequest request, HttpHeaders headers) {
        Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
        given(headersConverter.convert(request)).willReturn(headers);
        return headersConverter;
    }
}

Test Case ID #spring-security_Test_11_4

Test Case Name: getTokenResponseWhenHeadersConverterAddedThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactiveJwtBearerTokenResponseClientTests.java)

Mock Object Variable Name: addedHeadersConverter

--- original
+++ refactored
@@
    ClientRegistration clientRegistration = this.clientRegistration.build();
    JwtBearerGrantRequest request = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);
-    Converter<JwtBearerGrantRequest, HttpHeaders> addedHeadersConverter = mock();
    HttpHeaders headers = new HttpHeaders();
    headers.put("custom-header-name", Collections.singletonList("custom-header-value"));
-    given(addedHeadersConverter.convert(request)).willReturn(headers);
+    Converter<JwtBearerGrantRequest, HttpHeaders> addedHeadersConverter = MockConverter.createMockHeadersConverter(request, headers);
    this.client.addHeadersConverter(addedHeadersConverter);
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    this.client.getTokenResponse(request).block();
    verify(addedHeadersConverter).convert(request);
    RecordedRequest actualRequest = this.server.takeRequest();
    assertThat(actualRequest.getHeader(HttpHeaders.AUTHORIZATION)).isEqualTo("Basic Y2xpZW50LWlkOmNsaWVudC1zZWNyZXQ=");
    assertThat(actualRequest.getHeader("custom-header-name")).isEqualTo("custom-header-value");
@@

@Test

public void getTokenResponseWhenHeadersConverterAddedThenCalled() throws Exception {

    ClientRegistration clientRegistration = this.clientRegistration.build();

    JwtBearerGrantRequest request = new JwtBearerGrantRequest(clientRegistration, this.jwtAssertion);

    Converter<JwtBearerGrantRequest, HttpHeaders> addedHeadersConverter = mock();

    HttpHeaders headers = new HttpHeaders();

    headers.put("custom-header-name", Collections.singletonList("custom-header-value"));

    given(addedHeadersConverter.convert(request)).willReturn(headers);

    this.client.addHeadersConverter(addedHeadersConverter);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    this.client.getTokenResponse(request).block();

    verify(addedHeadersConverter).convert(request);

    RecordedRequest actualRequest = this.server.takeRequest();

    assertThat(actualRequest.getHeader(HttpHeaders.AUTHORIZATION)).isEqualTo("Basic Y2xpZW50LWlkOmNsaWVudC1zZWNyZXQ=");

    assertThat(actualRequest.getHeader("custom-header-name")).isEqualTo("custom-header-value");

}

public class MockConverter {
    public static Converter<JwtBearerGrantRequest, HttpHeaders> createMockHeadersConverter(JwtBearerGrantRequest request, HttpHeaders headers) {
        Converter<JwtBearerGrantRequest, HttpHeaders> headersConverter = mock();
        given(headersConverter.convert(request)).willReturn(headers);
        return headersConverter;
    }
}

Mock Clone Instance #spring-security_MCI_12

• Scope: method level
• Mocked Class: org.springframework.security.oauth2.server.resource.introspection.OpaqueTokenIntrospector
• Test Case Count: 3
• MO Count: 3

Reusable Method

private static OpaqueTokenIntrospector createMockOpaqueTokenIntrospector(OAuth2AuthenticatedPrincipal principal) {
    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);
    given(introspector.introspect(any())).willReturn(principal);
    return introspector;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_12_1

Test Case Name: authenticateWhenActiveTokenThenOk(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-resource-server\src\test\java\org\springframework\security\oauth2\server\resource\authentication\OpaqueTokenAuthenticationProviderTests.java)

Mock Object Variable Name: introspector

--- original
+++ refactored
@@
    OAuth2AuthenticatedPrincipal principal = TestOAuth2AuthenticatedPrincipals.active((attributes) -> attributes.put("extension_field", "twenty-seven"));
-    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);
-    given(introspector.introspect(any())).willReturn(principal);
+    OpaqueTokenIntrospector introspector = createMockOpaqueTokenIntrospector(principal);
    OpaqueTokenAuthenticationProvider provider = new OpaqueTokenAuthenticationProvider(introspector);
    Authentication result = provider.authenticate(new BearerTokenAuthenticationToken("token"));
    assertThat(result.getPrincipal()).isInstanceOf(OAuth2IntrospectionAuthenticatedPrincipal.class);
    Map<String, Object> attributes = ((OAuth2AuthenticatedPrincipal) result.getPrincipal()).getAttributes();
    // @formatter:off
    assertThat(attributes).isNotNull().containsEntry(OAuth2TokenIntrospectionClaimNames.ACTIVE, true).containsEntry(OAuth2TokenIntrospectionClaimNames.AUD, Arrays.asList("https://protected.example.net/resource")).containsEntry(OAuth2TokenIntrospectionClaimNames.CLIENT_ID, "l238j323ds-23ij4").containsEntry(OAuth2TokenIntrospectionClaimNames.EXP, Instant.ofEpochSecond(1419356238)).containsEntry(OAuth2TokenIntrospectionClaimNames.ISS, new URL("https://server.example.com/")).containsEntry(OAuth2TokenIntrospectionClaimNames.NBF, Instant.ofEpochSecond(29348723984L)).containsEntry(OAuth2TokenIntrospectionClaimNames.SCOPE, Arrays.asList("read", "write", "dolphin")).containsEntry(OAuth2TokenIntrospectionClaimNames.SUB, "Z5O3upPC88QrAjx00dis").containsEntry(OAuth2TokenIntrospectionClaimNames.USERNAME, "jdoe").containsEntry("extension_field", "twenty-seven");
    assertThat(result.getAuthorities()).extracting("authority").containsExactly("SCOPE_read", "SCOPE_write", "SCOPE_dolphin");
    // @formatter:on
@@

@Test

public void authenticateWhenActiveTokenThenOk() throws Exception {

    OAuth2AuthenticatedPrincipal principal = TestOAuth2AuthenticatedPrincipals.active((attributes) -> attributes.put("extension_field", "twenty-seven"));

    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);

    given(introspector.introspect(any())).willReturn(principal);

    OpaqueTokenAuthenticationProvider provider = new OpaqueTokenAuthenticationProvider(introspector);

    Authentication result = provider.authenticate(new BearerTokenAuthenticationToken("token"));

    assertThat(result.getPrincipal()).isInstanceOf(OAuth2IntrospectionAuthenticatedPrincipal.class);

    Map<String, Object> attributes = ((OAuth2AuthenticatedPrincipal) result.getPrincipal()).getAttributes();

    // @formatter:off

    assertThat(attributes).isNotNull().containsEntry(OAuth2TokenIntrospectionClaimNames.ACTIVE, true).containsEntry(OAuth2TokenIntrospectionClaimNames.AUD, Arrays.asList("https://protected.example.net/resource")).containsEntry(OAuth2TokenIntrospectionClaimNames.CLIENT_ID, "l238j323ds-23ij4").containsEntry(OAuth2TokenIntrospectionClaimNames.EXP, Instant.ofEpochSecond(1419356238)).containsEntry(OAuth2TokenIntrospectionClaimNames.ISS, new URL("https://server.example.com/")).containsEntry(OAuth2TokenIntrospectionClaimNames.NBF, Instant.ofEpochSecond(29348723984L)).containsEntry(OAuth2TokenIntrospectionClaimNames.SCOPE, Arrays.asList("read", "write", "dolphin")).containsEntry(OAuth2TokenIntrospectionClaimNames.SUB, "Z5O3upPC88QrAjx00dis").containsEntry(OAuth2TokenIntrospectionClaimNames.USERNAME, "jdoe").containsEntry("extension_field", "twenty-seven");

    assertThat(result.getAuthorities()).extracting("authority").containsExactly("SCOPE_read", "SCOPE_write", "SCOPE_dolphin");

    // @formatter:on

}

private static OpaqueTokenIntrospector createMockOpaqueTokenIntrospector(OAuth2AuthenticatedPrincipal principal) {
    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);
    given(introspector.introspect(any())).willReturn(principal);
    return introspector;
}

Test Case ID #spring-security_Test_12_2

Test Case Name: authenticateWhenMissingScopeAttributeThenNoAuthorities(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-resource-server\src\test\java\org\springframework\security\oauth2\server\resource\authentication\OpaqueTokenAuthenticationProviderTests.java)

Mock Object Variable Name: introspector

@@
    OAuth2AuthenticatedPrincipal principal = new OAuth2IntrospectionAuthenticatedPrincipal(Collections.singletonMap("claim", "value"), null);
-    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);
-    given(introspector.introspect(any())).willReturn(principal);
+    OpaqueTokenIntrospector introspector = createMockOpaqueTokenIntrospector(principal);
    OpaqueTokenAuthenticationProvider provider = new OpaqueTokenAuthenticationProvider(introspector);
    Authentication result = provider.authenticate(new BearerTokenAuthenticationToken("token"));
    assertThat(result.getPrincipal()).isInstanceOf(OAuth2AuthenticatedPrincipal.class);
    Map<String, Object> attributes = ((OAuth2AuthenticatedPrincipal) result.getPrincipal()).getAttributes();
    // @formatter:off
    assertThat(attributes).isNotNull().doesNotContainKey(OAuth2TokenIntrospectionClaimNames.SCOPE);
    // @formatter:on
    assertThat(result.getAuthorities()).isEmpty();
@@

@Test

public void authenticateWhenMissingScopeAttributeThenNoAuthorities() {

    OAuth2AuthenticatedPrincipal principal = new OAuth2IntrospectionAuthenticatedPrincipal(Collections.singletonMap("claim", "value"), null);

    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);

    given(introspector.introspect(any())).willReturn(principal);

    OpaqueTokenAuthenticationProvider provider = new OpaqueTokenAuthenticationProvider(introspector);

    Authentication result = provider.authenticate(new BearerTokenAuthenticationToken("token"));

    assertThat(result.getPrincipal()).isInstanceOf(OAuth2AuthenticatedPrincipal.class);

    Map<String, Object> attributes = ((OAuth2AuthenticatedPrincipal) result.getPrincipal()).getAttributes();

    // @formatter:off

    assertThat(attributes).isNotNull().doesNotContainKey(OAuth2TokenIntrospectionClaimNames.SCOPE);

    // @formatter:on

    assertThat(result.getAuthorities()).isEmpty();

}

private static OpaqueTokenIntrospector createMockOpaqueTokenIntrospector(OAuth2AuthenticatedPrincipal principal) {
    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);
    given(introspector.introspect(any())).willReturn(principal);
    return introspector;
}

Test Case ID #spring-security_Test_12_3

Test Case Name: authenticateWhenCustomAuthenticationConverterThenUses(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-resource-server\src\test\java\org\springframework\security\oauth2\server\resource\authentication\OpaqueTokenAuthenticationProviderTests.java)

Mock Object Variable Name: introspector

--- original
+++ refactored
@@
public void authenticateWhenCustomAuthenticationConverterThenUses() {
-    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);
    OAuth2AuthenticatedPrincipal principal = TestOAuth2AuthenticatedPrincipals.active();
-    given(introspector.introspect(any())).willReturn(principal);
+    OpaqueTokenIntrospector introspector = createMockOpaqueTokenIntrospector(principal);
    OpaqueTokenAuthenticationProvider provider = new OpaqueTokenAuthenticationProvider(introspector);
    OpaqueTokenAuthenticationConverter authenticationConverter = mock(OpaqueTokenAuthenticationConverter.class);
    given(authenticationConverter.convert(any(), any(OAuth2AuthenticatedPrincipal.class))).willReturn(new TestingAuthenticationToken(principal, null, Collections.emptyList()));
    provider.setAuthenticationConverter(authenticationConverter);
    Authentication result = provider.authenticate(new BearerTokenAuthenticationToken("token"));
    assertThat(result).isNotNull();
    verify(introspector).introspect("token");
    verify(authenticationConverter).convert("token", principal);
    verifyNoMoreInteractions(introspector, authenticationConverter);
}

@Test

public void authenticateWhenCustomAuthenticationConverterThenUses() {

    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);

    OAuth2AuthenticatedPrincipal principal = TestOAuth2AuthenticatedPrincipals.active();

    given(introspector.introspect(any())).willReturn(principal);

    OpaqueTokenAuthenticationProvider provider = new OpaqueTokenAuthenticationProvider(introspector);

    OpaqueTokenAuthenticationConverter authenticationConverter = mock(OpaqueTokenAuthenticationConverter.class);

    given(authenticationConverter.convert(any(), any(OAuth2AuthenticatedPrincipal.class))).willReturn(new TestingAuthenticationToken(principal, null, Collections.emptyList()));

    provider.setAuthenticationConverter(authenticationConverter);

    Authentication result = provider.authenticate(new BearerTokenAuthenticationToken("token"));

    assertThat(result).isNotNull();

    verify(introspector).introspect("token");

    verify(authenticationConverter).convert("token", principal);

    verifyNoMoreInteractions(introspector, authenticationConverter);

}

private static OpaqueTokenIntrospector createMockOpaqueTokenIntrospector(OAuth2AuthenticatedPrincipal principal) {
    OpaqueTokenIntrospector introspector = mock(OpaqueTokenIntrospector.class);
    given(introspector.introspect(any())).willReturn(principal);
    return introspector;
}

Mock Clone Instance #spring-security_MCI_13

• Scope: method level
• Mocked Class: org.springframework.security.authorization.AuthorizationManager<org.aopalliance.intercept.MethodInvocation>
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static AuthorizationManager<MethodInvocation> createMockAuthorizationManager() {
    AuthorizationManager<MethodInvocation> mockAuthorizationManager = mock(AuthorizationManager.class);
    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockAuthorizationManager;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_13_1

Test Case Name: beforeWhenMockAuthorizationManagerThenCheck(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authorization\method\AuthorizationManagerBeforeMethodInterceptorTests.java)

Mock Object Variable Name: mockAuthorizationManager

--- original
+++ refactored
@@
    MethodInvocation mockMethodInvocation = mock(MethodInvocation.class);
-    AuthorizationManager<MethodInvocation> mockAuthorizationManager = mock(AuthorizationManager.class);
-    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
+    AuthorizationManager<MethodInvocation> mockAuthorizationManager = createMockAuthorizationManager();
    AuthorizationManagerBeforeMethodInterceptor advice = new AuthorizationManagerBeforeMethodInterceptor(Pointcut.TRUE, mockAuthorizationManager);
    advice.invoke(mockMethodInvocation);
    verify(mockAuthorizationManager).check(any(Supplier.class), eq(mockMethodInvocation));
@@

@Test

public void beforeWhenMockAuthorizationManagerThenCheck() throws Throwable {

    MethodInvocation mockMethodInvocation = mock(MethodInvocation.class);

    AuthorizationManager<MethodInvocation> mockAuthorizationManager = mock(AuthorizationManager.class);

    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();

    AuthorizationManagerBeforeMethodInterceptor advice = new AuthorizationManagerBeforeMethodInterceptor(Pointcut.TRUE, mockAuthorizationManager);

    advice.invoke(mockMethodInvocation);

    verify(mockAuthorizationManager).check(any(Supplier.class), eq(mockMethodInvocation));

}

private static AuthorizationManager<MethodInvocation> createMockAuthorizationManager() {
    AuthorizationManager<MethodInvocation> mockAuthorizationManager = mock(AuthorizationManager.class);
    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockAuthorizationManager;
}

Test Case ID #spring-security_Test_13_2

Test Case Name: invokeWhenCustomAuthorizationDeniedExceptionThenThrows(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authorization\method\AuthorizationManagerBeforeMethodInterceptorTests.java)

Mock Object Variable Name: manager

@@
 @Test
 public void invokeWhenCustomAuthorizationDeniedExceptionThenThrows() {
-    AuthorizationManager<MethodInvocation> manager = mock(AuthorizationManager.class);
-    given(manager.check(any(), any())).willThrow(new MyAuthzDeniedException("denied", new AuthorizationDecision(false)));
-    given(manager.authorize(any(), any())).willCallRealMethod();
+    AuthorizationManager<MethodInvocation> manager = createMockAuthorizationManager();
+    given(manager.check(any(), any())).willThrow(new MyAuthzDeniedException("denied", new AuthorizationDecision(false)));
     AuthorizationManagerBeforeMethodInterceptor advice = new AuthorizationManagerBeforeMethodInterceptor(Pointcut.TRUE, manager);
     assertThatExceptionOfType(MyAuthzDeniedException.class).isThrownBy(() -> advice.invoke(null));
 }
@@

@Test

public void invokeWhenCustomAuthorizationDeniedExceptionThenThrows() {

    AuthorizationManager<MethodInvocation> manager = mock(AuthorizationManager.class);

    given(manager.check(any(), any())).willThrow(new MyAuthzDeniedException("denied", new AuthorizationDecision(false)));

    given(manager.authorize(any(), any())).willCallRealMethod();

    AuthorizationManagerBeforeMethodInterceptor advice = new AuthorizationManagerBeforeMethodInterceptor(Pointcut.TRUE, manager);

    assertThatExceptionOfType(MyAuthzDeniedException.class).isThrownBy(() -> advice.invoke(null));

}

private static AuthorizationManager<MethodInvocation> createMockAuthorizationManager() {
    AuthorizationManager<MethodInvocation> mockAuthorizationManager = mock(AuthorizationManager.class);
    given(mockAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockAuthorizationManager;
}

Mock Clone Instance #spring-security_MCI_14

• Scope: method level
• Mocked Class: org.springframework.security.acls.model.Acl
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static Acl createMockAcl() {
    Acl acl = mock(Acl.class);
    given(acl.isGranted(anyList(), anyList(), eq(false))).willReturn(true);
    return acl;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_14_1

Test Case Name: hasPermissionReturnsTrueIfAclGrantsPermission(File: C:\Java_projects\Spring\spring-security\acl\src\test\java\org\springframework\security\acls\AclPermissionEvaluatorTests.java)

Mock Object Variable Name: acl

@@
    pe.setSidRetrievalStrategy(mock(SidRetrievalStrategy.class));
-    Acl acl = mock(Acl.class);
+    Acl acl = createMockAcl();
    given(service.readAclById(any(ObjectIdentity.class), anyList())).willReturn(acl);
-    given(acl.isGranted(anyList(), anyList(), eq(false))).willReturn(true);
    assertThat(pe.hasPermission(mock(Authentication.class), new Object(), "READ")).isTrue();

@Test

public void hasPermissionReturnsTrueIfAclGrantsPermission() {

    AclService service = mock(AclService.class);

    AclPermissionEvaluator pe = new AclPermissionEvaluator(service);

    ObjectIdentity oid = mock(ObjectIdentity.class);

    ObjectIdentityRetrievalStrategy oidStrategy = mock(ObjectIdentityRetrievalStrategy.class);

    given(oidStrategy.getObjectIdentity(any(Object.class))).willReturn(oid);

    pe.setObjectIdentityRetrievalStrategy(oidStrategy);

    pe.setSidRetrievalStrategy(mock(SidRetrievalStrategy.class));

    Acl acl = mock(Acl.class);

    given(service.readAclById(any(ObjectIdentity.class), anyList())).willReturn(acl);

    given(acl.isGranted(anyList(), anyList(), eq(false))).willReturn(true);

    assertThat(pe.hasPermission(mock(Authentication.class), new Object(), "READ")).isTrue();

}

private static Acl createMockAcl() {
    Acl acl = mock(Acl.class);
    given(acl.isGranted(anyList(), anyList(), eq(false))).willReturn(true);
    return acl;
}

Test Case ID #spring-security_Test_14_2

Test Case Name: resolvePermissionNonEnglishLocale(File: C:\Java_projects\Spring\spring-security\acl\src\test\java\org\springframework\security\acls\AclPermissionEvaluatorTests.java)

Mock Object Variable Name: acl

--- original
+++ refactored
@@
    pe.setSidRetrievalStrategy(mock(SidRetrievalStrategy.class));
-    Acl acl = mock(Acl.class);
-    given(service.readAclById(any(ObjectIdentity.class), anyList())).willReturn(acl);
-    given(acl.isGranted(anyList(), anyList(), eq(false))).willReturn(true);
+    Acl acl = createMockAcl();
+    given(service.readAclById(any(ObjectIdentity.class), anyList())).willReturn(acl);
    assertThat(pe.hasPermission(mock(Authentication.class), new Object(), "write")).isTrue();
    Locale.setDefault(systemLocale);
@@

@Test

public void resolvePermissionNonEnglishLocale() {

    Locale systemLocale = Locale.getDefault();

    Locale.setDefault(new Locale("tr"));

    AclService service = mock(AclService.class);

    AclPermissionEvaluator pe = new AclPermissionEvaluator(service);

    ObjectIdentity oid = mock(ObjectIdentity.class);

    ObjectIdentityRetrievalStrategy oidStrategy = mock(ObjectIdentityRetrievalStrategy.class);

    given(oidStrategy.getObjectIdentity(any(Object.class))).willReturn(oid);

    pe.setObjectIdentityRetrievalStrategy(oidStrategy);

    pe.setSidRetrievalStrategy(mock(SidRetrievalStrategy.class));

    Acl acl = mock(Acl.class);

    given(service.readAclById(any(ObjectIdentity.class), anyList())).willReturn(acl);

    given(acl.isGranted(anyList(), anyList(), eq(false))).willReturn(true);

    assertThat(pe.hasPermission(mock(Authentication.class), new Object(), "write")).isTrue();

    Locale.setDefault(systemLocale);

}

private static Acl createMockAcl() {
    Acl acl = mock(Acl.class);
    given(acl.isGranted(anyList(), anyList(), eq(false))).willReturn(true);
    return acl;
}

Mock Clone Instance #spring-security_MCI_15

• Scope: method level
• Mocked Class: org.springframework.security.acls.model.Acl
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static Acl createMockAcl(boolean isGrantedReturn) {
    Acl acl = mock(Acl.class);
    given(acl.isGranted(any(List.class), any(List.class), anyBoolean())).willReturn(isGrantedReturn);
    return acl;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_15_1

Test Case Name: accessIsAllowedIfPermissionIsGranted(File: C:\Java_projects\Spring\spring-security\acl\src\test\java\org\springframework\security\acls\afterinvocation\AclEntryAfterInvocationProviderTests.java)

Mock Object Variable Name: acl

--- original
+++ refactored
@@
    AclService service = mock(AclService.class);
-    Acl acl = mock(Acl.class);
-    given(acl.isGranted(any(List.class), any(List.class), anyBoolean())).willReturn(true);
+    Acl acl = createMockAcl(true);
    given(service.readAclById(any(), any())).willReturn(acl);
    AclEntryAfterInvocationProvider provider = new AclEntryAfterInvocationProvider(service, Arrays.asList(mock(Permission.class)));
    provider.setMessageSource(new SpringSecurityMessageSource());
    provider.setObjectIdentityRetrievalStrategy(mock(ObjectIdentityRetrievalStrategy.class));
    provider.setProcessDomainObjectClass(Object.class);
    provider.setSidRetrievalStrategy(mock(SidRetrievalStrategy.class));
    Object returned = new Object();
    assertThat(returned).isSameAs(provider.decide(mock(Authentication.class), new Object(), SecurityConfig.createList("AFTER_ACL_READ"), returned));
@@

@Test

public void accessIsAllowedIfPermissionIsGranted() {

    AclService service = mock(AclService.class);

    Acl acl = mock(Acl.class);

    given(acl.isGranted(any(List.class), any(List.class), anyBoolean())).willReturn(true);

    given(service.readAclById(any(), any())).willReturn(acl);

    AclEntryAfterInvocationProvider provider = new AclEntryAfterInvocationProvider(service, Arrays.asList(mock(Permission.class)));

    provider.setMessageSource(new SpringSecurityMessageSource());

    provider.setObjectIdentityRetrievalStrategy(mock(ObjectIdentityRetrievalStrategy.class));

    provider.setProcessDomainObjectClass(Object.class);

    provider.setSidRetrievalStrategy(mock(SidRetrievalStrategy.class));

    Object returned = new Object();

    assertThat(returned).isSameAs(provider.decide(mock(Authentication.class), new Object(), SecurityConfig.createList("AFTER_ACL_READ"), returned));

}

private static Acl createMockAcl(boolean isGrantedReturn) {
    Acl acl = mock(Acl.class);
    given(acl.isGranted(any(List.class), any(List.class), anyBoolean())).willReturn(isGrantedReturn);
    return acl;
}

Test Case ID #spring-security_Test_15_2

Test Case Name: accessIsDeniedIfPermissionIsNotGranted(File: C:\Java_projects\Spring\spring-security\acl\src\test\java\org\springframework\security\acls\afterinvocation\AclEntryAfterInvocationProviderTests.java)

Mock Object Variable Name: acl

--- original
+++ refactored
@@
    AclService service = mock(AclService.class);
-    Acl acl = mock(Acl.class);
-    given(acl.isGranted(any(List.class), any(List.class), anyBoolean())).willReturn(false);
+    Acl acl = createMockAcl(false);
    // Try a second time with no permissions found
    given(acl.isGranted(any(), any(List.class), anyBoolean())).willThrow(new NotFoundException(""));
    given(service.readAclById(any(), any())).willReturn(acl);
    AclEntryAfterInvocationProvider provider = new AclEntryAfterInvocationProvider(service, Arrays.asList(mock(Permission.class)));
@@

@Test

public void accessIsDeniedIfPermissionIsNotGranted() {

    AclService service = mock(AclService.class);

    Acl acl = mock(Acl.class);

    given(acl.isGranted(any(List.class), any(List.class), anyBoolean())).willReturn(false);

    // Try a second time with no permissions found

    given(acl.isGranted(any(), any(List.class), anyBoolean())).willThrow(new NotFoundException(""));

    given(service.readAclById(any(), any())).willReturn(acl);

    AclEntryAfterInvocationProvider provider = new AclEntryAfterInvocationProvider(service, Arrays.asList(mock(Permission.class)));

    provider.setProcessConfigAttribute("MY_ATTRIBUTE");

    provider.setMessageSource(new SpringSecurityMessageSource());

    provider.setObjectIdentityRetrievalStrategy(mock(ObjectIdentityRetrievalStrategy.class));

    provider.setProcessDomainObjectClass(Object.class);

    provider.setSidRetrievalStrategy(mock(SidRetrievalStrategy.class));

    assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(() -> provider.decide(mock(Authentication.class), new Object(), SecurityConfig.createList("UNSUPPORTED", "MY_ATTRIBUTE"), new Object()));

    // Second scenario with no acls found

    assertThatExceptionOfType(AccessDeniedException.class).isThrownBy(() -> provider.decide(mock(Authentication.class), new Object(), SecurityConfig.createList("UNSUPPORTED", "MY_ATTRIBUTE"), new Object()));

}

private static Acl createMockAcl(boolean isGrantedReturn) {
    Acl acl = mock(Acl.class);
    given(acl.isGranted(any(List.class), any(List.class), anyBoolean())).willReturn(isGrantedReturn);
    return acl;
}

Mock Clone Instance #spring-security_MCI_16

• Scope: method level
• Mocked Class: org.springframework.security.authentication.AuthenticationTrustResolver
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static AuthenticationTrustResolver createMockAuthenticationTrustResolver(Authentication authentication, boolean isAuthenticatedReturn) {
    AuthenticationTrustResolver atr = mock(AuthenticationTrustResolver.class);
    given(atr.isAuthenticated(authentication)).willReturn(isAuthenticatedReturn);
    return atr;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_16_1

Test Case Name: isAuthenticatedWhenTrustResolverFalseThenFalse(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\access\expression\SecurityExpressionRootTests.java)

Mock Object Variable Name: atr

--- original
+++ refactored
@@
void isAuthenticatedWhenTrustResolverFalseThenFalse() {
-    AuthenticationTrustResolver atr = mock(AuthenticationTrustResolver.class);
-    given(atr.isAuthenticated(JOE)).willReturn(false);
+    AuthenticationTrustResolver atr = createMockAuthenticationTrustResolver(JOE, false);
    this.root.setTrustResolver(atr);
    assertThat(this.root.isAuthenticated()).isFalse();
}

@Test

void isAuthenticatedWhenTrustResolverFalseThenFalse() {

    AuthenticationTrustResolver atr = mock(AuthenticationTrustResolver.class);

    given(atr.isAuthenticated(JOE)).willReturn(false);

    this.root.setTrustResolver(atr);

    assertThat(this.root.isAuthenticated()).isFalse();

}

private static AuthenticationTrustResolver createMockAuthenticationTrustResolver(Authentication authentication, boolean isAuthenticatedReturn) {
    AuthenticationTrustResolver atr = mock(AuthenticationTrustResolver.class);
    given(atr.isAuthenticated(authentication)).willReturn(isAuthenticatedReturn);
    return atr;
}

Test Case ID #spring-security_Test_16_2

Test Case Name: isAuthenticatedWhenTrustResolverTrueThenTrue(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\access\expression\SecurityExpressionRootTests.java)

Mock Object Variable Name: atr

@@
 void isAuthenticatedWhenTrustResolverTrueThenTrue() {
-    AuthenticationTrustResolver atr = mock(AuthenticationTrustResolver.class);
-    given(atr.isAuthenticated(JOE)).willReturn(true);
+    AuthenticationTrustResolver atr = createMockAuthenticationTrustResolver(JOE, true);
    this.root.setTrustResolver(atr);
    assertThat(this.root.isAuthenticated()).isTrue();
}

@Test

void isAuthenticatedWhenTrustResolverTrueThenTrue() {

    AuthenticationTrustResolver atr = mock(AuthenticationTrustResolver.class);

    given(atr.isAuthenticated(JOE)).willReturn(true);

    this.root.setTrustResolver(atr);

    assertThat(this.root.isAuthenticated()).isTrue();

}

private static AuthenticationTrustResolver createMockAuthenticationTrustResolver(Authentication authentication, boolean isAuthenticatedReturn) {
    AuthenticationTrustResolver atr = mock(AuthenticationTrustResolver.class);
    given(atr.isAuthenticated(authentication)).willReturn(isAuthenticatedReturn);
    return atr;
}

Mock Clone Instance #spring-security_MCI_17

• Scope: method level
• Mocked Class: org.springframework.core.convert.converter.Converter<org.springframework.security.oauth2.client.endpoint.OAuth2PasswordGrantRequest, org.springframework.util.MultiValueMap<java.lang.String, java.lang.String>>
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> createMockParametersConverter(OAuth2PasswordGrantRequest request, MultiValueMap<String, String> parameters) {
    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> parametersConverter = mock();
    given(parametersConverter.convert(request)).willReturn(parameters);
    return parametersConverter;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_17_1

Test Case Name: getTokenResponseWhenParametersConverterAddedThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactivePasswordTokenResponseClientTests.java)

Mock Object Variable Name: addedParametersConverter

--- original
+++ refactored
@@
    OAuth2PasswordGrantRequest request = new OAuth2PasswordGrantRequest(this.clientRegistrationBuilder.build(), this.username, this.password);
-    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> addedParametersConverter = mock();
    MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
    parameters.add("custom-parameter-name", "custom-parameter-value");
+    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> addedParametersConverter = createMockParametersConverter(request, parameters);
    this.tokenResponseClient.addParametersConverter(addedParametersConverter);
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    this.tokenResponseClient.getTokenResponse(request).block();
    verify(addedParametersConverter).convert(request);
    RecordedRequest actualRequest = this.server.takeRequest();
    String formParameters = actualRequest.getBody().readUtf8();
    // @formatter:off
    assertThat(formParameters).contains(param(OAuth2ParameterNames.GRANT_TYPE, "password"), param("custom-parameter-name", "custom-parameter-value"));
    // @formatter:on
@@

@Test

public void getTokenResponseWhenParametersConverterAddedThenCalled() throws Exception {

    OAuth2PasswordGrantRequest request = new OAuth2PasswordGrantRequest(this.clientRegistrationBuilder.build(), this.username, this.password);

    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> addedParametersConverter = mock();

    MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();

    parameters.add("custom-parameter-name", "custom-parameter-value");

    given(addedParametersConverter.convert(request)).willReturn(parameters);

    this.tokenResponseClient.addParametersConverter(addedParametersConverter);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    this.tokenResponseClient.getTokenResponse(request).block();

    verify(addedParametersConverter).convert(request);

    RecordedRequest actualRequest = this.server.takeRequest();

    String formParameters = actualRequest.getBody().readUtf8();

    // @formatter:off

    assertThat(formParameters).contains(param(OAuth2ParameterNames.GRANT_TYPE, "password"), param("custom-parameter-name", "custom-parameter-value"));

    // @formatter:on

}

private static Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> createMockParametersConverter(OAuth2PasswordGrantRequest request, MultiValueMap<String, String> parameters) {
    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> parametersConverter = mock();
    given(parametersConverter.convert(request)).willReturn(parameters);
    return parametersConverter;
}

Test Case ID #spring-security_Test_17_2

Test Case Name: getTokenResponseWhenParametersConverterSetThenCalled(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\endpoint\WebClientReactivePasswordTokenResponseClientTests.java)

Mock Object Variable Name: parametersConverter

--- original
+++ refactored
@@
    OAuth2PasswordGrantRequest request = new OAuth2PasswordGrantRequest(this.clientRegistrationBuilder.build(), this.username, this.password);
-    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> parametersConverter = mock();
    MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
    parameters.add("custom-parameter-name", "custom-parameter-value");
-    given(parametersConverter.convert(request)).willReturn(parameters);
+    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> parametersConverter = createMockParametersConverter(request, parameters);
    this.tokenResponseClient.setParametersConverter(parametersConverter);
    this.server.enqueue(MockResponses.json("access-token-response.json"));
    this.tokenResponseClient.getTokenResponse(request).block();
    verify(parametersConverter).convert(request);
    RecordedRequest actualRequest = this.server.takeRequest();
    assertThat(actualRequest.getBody().readUtf8()).contains("custom-parameter-name=custom-parameter-value");
@@

@Test

public void getTokenResponseWhenParametersConverterSetThenCalled() throws Exception {

    OAuth2PasswordGrantRequest request = new OAuth2PasswordGrantRequest(this.clientRegistrationBuilder.build(), this.username, this.password);

    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> parametersConverter = mock();

    MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();

    parameters.add("custom-parameter-name", "custom-parameter-value");

    given(parametersConverter.convert(request)).willReturn(parameters);

    this.tokenResponseClient.setParametersConverter(parametersConverter);

    this.server.enqueue(MockResponses.json("access-token-response.json"));

    this.tokenResponseClient.getTokenResponse(request).block();

    verify(parametersConverter).convert(request);

    RecordedRequest actualRequest = this.server.takeRequest();

    assertThat(actualRequest.getBody().readUtf8()).contains("custom-parameter-name=custom-parameter-value");

}

private static Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> createMockParametersConverter(OAuth2PasswordGrantRequest request, MultiValueMap<String, String> parameters) {
    Converter<OAuth2PasswordGrantRequest, MultiValueMap<String, String>> parametersConverter = mock();
    given(parametersConverter.convert(request)).willReturn(parameters);
    return parametersConverter;
}

Mock Clone Instance #spring-security_MCI_18

• Scope: method level
• Mocked Class: org.springframework.security.oauth2.core.user.OAuth2User
• Test Case Count: 3
• MO Count: 3

Reusable Method

private static OAuth2User createMockOAuth2User(List<GrantedAuthority> authorities) {
    OAuth2User principal = mock(OAuth2User.class);
    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);
    return principal;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_18_1

Test Case Name: authenticateWhenLoginSuccessThenReturnAuthentication(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\authentication\OAuth2LoginAuthenticationProviderTests.java)

Mock Object Variable Name: principal

@@
    given(this.accessTokenResponseClient.getTokenResponse(any())).willReturn(accessTokenResponse);
-    OAuth2User principal = mock(OAuth2User.class);
     List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("ROLE_USER");
-    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);
+    OAuth2User principal = createMockOAuth2User(authorities);
     given(this.userService.loadUser(any())).willReturn(principal);
     OAuth2LoginAuthenticationToken authentication = (OAuth2LoginAuthenticationToken) this.authenticationProvider.authenticate(new OAuth2LoginAuthenticationToken(this.clientRegistration, this.authorizationExchange));
     assertThat(authentication.isAuthenticated()).isTrue();
     assertThat(authentication.getPrincipal()).isEqualTo(principal);
@@

@Test

public void authenticateWhenLoginSuccessThenReturnAuthentication() {

    OAuth2AccessTokenResponse accessTokenResponse = this.accessTokenSuccessResponse();

    given(this.accessTokenResponseClient.getTokenResponse(any())).willReturn(accessTokenResponse);

    OAuth2User principal = mock(OAuth2User.class);

    List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("ROLE_USER");

    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);

    given(this.userService.loadUser(any())).willReturn(principal);

    OAuth2LoginAuthenticationToken authentication = (OAuth2LoginAuthenticationToken) this.authenticationProvider.authenticate(new OAuth2LoginAuthenticationToken(this.clientRegistration, this.authorizationExchange));

    assertThat(authentication.isAuthenticated()).isTrue();

    assertThat(authentication.getPrincipal()).isEqualTo(principal);

    assertThat(authentication.getCredentials()).isEqualTo("");

    assertThat(authentication.getAuthorities()).isEqualTo(authorities);

    assertThat(authentication.getClientRegistration()).isEqualTo(this.clientRegistration);

    assertThat(authentication.getAuthorizationExchange()).isEqualTo(this.authorizationExchange);

    assertThat(authentication.getAccessToken()).isEqualTo(accessTokenResponse.getAccessToken());

    assertThat(authentication.getRefreshToken()).isEqualTo(accessTokenResponse.getRefreshToken());

}

private static OAuth2User createMockOAuth2User(List<GrantedAuthority> authorities) {
    OAuth2User principal = mock(OAuth2User.class);
    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);
    return principal;
}

Test Case ID #spring-security_Test_18_2

Test Case Name: authenticateWhenAuthoritiesMapperSetThenReturnMappedAuthorities(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\authentication\OAuth2LoginAuthenticationProviderTests.java)

Mock Object Variable Name: principal

--- original
+++ refactored
@@
    given(this.accessTokenResponseClient.getTokenResponse(any())).willReturn(accessTokenResponse);
-    OAuth2User principal = mock(OAuth2User.class);
    List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("ROLE_USER");
-    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);
+    OAuth2User principal = createMockOAuth2User(authorities);
    given(this.userService.loadUser(any())).willReturn(principal);
    List<GrantedAuthority> mappedAuthorities = AuthorityUtils.createAuthorityList("ROLE_OAUTH2_USER");
@@

@Test

public void authenticateWhenAuthoritiesMapperSetThenReturnMappedAuthorities() {

    OAuth2AccessTokenResponse accessTokenResponse = this.accessTokenSuccessResponse();

    given(this.accessTokenResponseClient.getTokenResponse(any())).willReturn(accessTokenResponse);

    OAuth2User principal = mock(OAuth2User.class);

    List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("ROLE_USER");

    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);

    given(this.userService.loadUser(any())).willReturn(principal);

    List<GrantedAuthority> mappedAuthorities = AuthorityUtils.createAuthorityList("ROLE_OAUTH2_USER");

    GrantedAuthoritiesMapper authoritiesMapper = mock(GrantedAuthoritiesMapper.class);

    given(authoritiesMapper.mapAuthorities(anyCollection())).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> mappedAuthorities);

    this.authenticationProvider.setAuthoritiesMapper(authoritiesMapper);

    OAuth2LoginAuthenticationToken authentication = (OAuth2LoginAuthenticationToken) this.authenticationProvider.authenticate(new OAuth2LoginAuthenticationToken(this.clientRegistration, this.authorizationExchange));

    assertThat(authentication.getAuthorities()).isEqualTo(mappedAuthorities);

}

private static OAuth2User createMockOAuth2User(List<GrantedAuthority> authorities) {
    OAuth2User principal = mock(OAuth2User.class);
    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);
    return principal;
}

Test Case ID #spring-security_Test_18_3

Test Case Name: authenticateWhenTokenSuccessResponseThenAdditionalParametersAddedToUserRequest(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-client\src\test\java\org\springframework\security\oauth2\client\authentication\OAuth2LoginAuthenticationProviderTests.java)

Mock Object Variable Name: principal

@@
    given(this.accessTokenResponseClient.getTokenResponse(any())).willReturn(accessTokenResponse);
-    OAuth2User principal = mock(OAuth2User.class);
    List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("ROLE_USER");
-    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);
+    OAuth2User principal = createMockOAuth2User(authorities);
    ArgumentCaptor<OAuth2UserRequest> userRequestArgCaptor = ArgumentCaptor.forClass(OAuth2UserRequest.class);
    given(this.userService.loadUser(userRequestArgCaptor.capture())).willReturn(principal);
    this.authenticationProvider.authenticate(new OAuth2LoginAuthenticationToken(this.clientRegistration, this.authorizationExchange));
    assertThat(userRequestArgCaptor.getValue().getAdditionalParameters()).containsAllEntriesOf(accessTokenResponse.getAdditionalParameters());
@@

// gh-5368

@Test

public void authenticateWhenTokenSuccessResponseThenAdditionalParametersAddedToUserRequest() {

    OAuth2AccessTokenResponse accessTokenResponse = this.accessTokenSuccessResponse();

    given(this.accessTokenResponseClient.getTokenResponse(any())).willReturn(accessTokenResponse);

    OAuth2User principal = mock(OAuth2User.class);

    List<GrantedAuthority> authorities = AuthorityUtils.createAuthorityList("ROLE_USER");

    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);

    ArgumentCaptor<OAuth2UserRequest> userRequestArgCaptor = ArgumentCaptor.forClass(OAuth2UserRequest.class);

    given(this.userService.loadUser(userRequestArgCaptor.capture())).willReturn(principal);

    this.authenticationProvider.authenticate(new OAuth2LoginAuthenticationToken(this.clientRegistration, this.authorizationExchange));

    assertThat(userRequestArgCaptor.getValue().getAdditionalParameters()).containsAllEntriesOf(accessTokenResponse.getAdditionalParameters());

}

private static OAuth2User createMockOAuth2User(List<GrantedAuthority> authorities) {
    OAuth2User principal = mock(OAuth2User.class);
    given(principal.getAuthorities()).willAnswer((Answer<List<GrantedAuthority>>) (invocation) -> authorities);
    return principal;
}

Mock Clone Instance #spring-security_MCI_19

• Scope: method level
• Mocked Class: org.springframework.security.config.ObjectPostProcessor<java.lang.Object>
• Test Case Count: 4
• MO Count: 4

Reusable Method

// === Declare in class scope ===
private ObjectPostProcessor<Object> opp;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    opp = mock(ObjectPostProcessor.class);
}

// === Replace local variable in test with ===
opp

The refactoring details in each test cases

Test Case ID #spring-security_Test_19_1

Test Case Name: buildWhenAddAuthenticationProviderThenDoesNotPerformRegistration(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\authentication\AuthenticationManagerBuilderTests.java)

Mock Object Variable Name: opp

@@
 @Test
 public void buildWhenAddAuthenticationProviderThenDoesNotPerformRegistration() throws Exception {
-    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);
+    // removed local mock; replaced with global field `opp`
     AuthenticationProvider provider = mock(AuthenticationProvider.class);
     AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);
     builder.authenticationProvider(provider);
     builder.build();
     verify(opp, never()).postProcess(provider);
}

@Test

public void buildWhenAddAuthenticationProviderThenDoesNotPerformRegistration() throws Exception {

    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);

    AuthenticationProvider provider = mock(AuthenticationProvider.class);

    AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);

    builder.authenticationProvider(provider);

    builder.build();

    verify(opp, never()).postProcess(provider);

}

// === Declare in class scope ===
private ObjectPostProcessor<Object> opp;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    opp = mock(ObjectPostProcessor.class);
}

// === Replace local variable in test with ===
opp

Test Case ID #spring-security_Test_19_2

Test Case Name: buildWhenAuthenticationProviderThenIsConfigured(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\authentication\AuthenticationManagerBuilderTests.java)

Mock Object Variable Name: opp

@@
 @Test
 public void buildWhenAuthenticationProviderThenIsConfigured() throws Exception {
-    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);
+    // removed local mock; replaced with global field `opp`
     AuthenticationProvider provider = mock(AuthenticationProvider.class);
-    AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);
+    AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);
     builder.authenticationProvider(provider);
     builder.build();
     assertThat(builder.isConfigured()).isTrue();
}

@Test

public void buildWhenAuthenticationProviderThenIsConfigured() throws Exception {

    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);

    AuthenticationProvider provider = mock(AuthenticationProvider.class);

    AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);

    builder.authenticationProvider(provider);

    builder.build();

    assertThat(builder.isConfigured()).isTrue();

}

// === Declare in class scope ===
private ObjectPostProcessor<Object> opp;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    opp = mock(ObjectPostProcessor.class);
}

// === Replace local variable in test with ===
opp

Test Case ID #spring-security_Test_19_3

Test Case Name: buildWhenParentThenIsConfigured(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\authentication\AuthenticationManagerBuilderTests.java)

Mock Object Variable Name: opp

@@
 @Test
 public void buildWhenParentThenIsConfigured() throws Exception {
-    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);
+    // removed local mock; replaced with global field `opp`
     AuthenticationManager parent = mock(AuthenticationManager.class);
     AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);
     builder.parentAuthenticationManager(parent);
     builder.build();
     assertThat(builder.isConfigured()).isTrue();
}

@Test

public void buildWhenParentThenIsConfigured() throws Exception {

    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);

    AuthenticationManager parent = mock(AuthenticationManager.class);

    AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);

    builder.parentAuthenticationManager(parent);

    builder.build();

    assertThat(builder.isConfigured()).isTrue();

}

// === Declare in class scope ===
private ObjectPostProcessor<Object> opp;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    opp = mock(ObjectPostProcessor.class);
}

// === Replace local variable in test with ===
opp

Test Case ID #spring-security_Test_19_4

Test Case Name: buildWhenNotConfiguredThenIsConfiguredFalse(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\authentication\AuthenticationManagerBuilderTests.java)

Mock Object Variable Name: opp

@@
 @Test
 public void buildWhenNotConfiguredThenIsConfiguredFalse() throws Exception {
-    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);
+    // removed local mock; replaced with global field `opp`
     AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);
     builder.build();
     assertThat(builder.isConfigured()).isFalse();
}

@Test

public void buildWhenNotConfiguredThenIsConfiguredFalse() throws Exception {

    ObjectPostProcessor<Object> opp = mock(ObjectPostProcessor.class);

    AuthenticationManagerBuilder builder = new AuthenticationManagerBuilder(opp);

    builder.build();

    assertThat(builder.isConfigured()).isFalse();

}

// === Declare in class scope ===
private ObjectPostProcessor<Object> opp;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    opp = mock(ObjectPostProcessor.class);
}

// === Replace local variable in test with ===
opp

Mock Clone Instance #spring-security_MCI_20

• Scope: method level
• Mocked Class: com.nimbusds.jose.jwk.source.JWKSource<com.nimbusds.jose.proc.SecurityContext>
• Test Case Count: 3
• MO Count: 3

Reusable Method

private static JWKSource<SecurityContext> createMockJwkSource(List<RSAKey> keysToReturn) {
    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(keysToReturn);
    return jwkSource;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_20_1

Test Case Name: getSignatureAlgorithmsWhenJwkSetSpecifiesAlgorithmThenUses(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\JwtDecoderProviderConfigurationUtilsTests.java)

Mock Object Variable Name: jwkSource

@@
 @Test
 public void getSignatureAlgorithmsWhenJwkSetSpecifiesAlgorithmThenUses() throws Exception {
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
     RSAKey key = new RSAKey.Builder(TestKeys.DEFAULT_PUBLIC_KEY).keyUse(KeyUse.SIGNATURE).algorithm(JWSAlgorithm.RS384).build();
-    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(Collections.singletonList(key));
+    JWKSource<SecurityContext> jwkSource = createMockJwkSource(Collections.singletonList(key));
     Set<SignatureAlgorithm> algorithms = JwtDecoderProviderConfigurationUtils.getSignatureAlgorithms(jwkSource);
     assertThat(algorithms).containsOnly(SignatureAlgorithm.RS384);
 }
@@

@Test

public void getSignatureAlgorithmsWhenJwkSetSpecifiesAlgorithmThenUses() throws Exception {

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    RSAKey key = new RSAKey.Builder(TestKeys.DEFAULT_PUBLIC_KEY).keyUse(KeyUse.SIGNATURE).algorithm(JWSAlgorithm.RS384).build();

    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(Collections.singletonList(key));

    Set<SignatureAlgorithm> algorithms = JwtDecoderProviderConfigurationUtils.getSignatureAlgorithms(jwkSource);

    assertThat(algorithms).containsOnly(SignatureAlgorithm.RS384);

}

private static JWKSource<SecurityContext> createMockJwkSource(List<RSAKey> keysToReturn) {
    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(keysToReturn);
    return jwkSource;
}

Test Case ID #spring-security_Test_20_2

Test Case Name: getSignatureAlgorithmsWhenJwkSetSpecifiesFamilyThenUses(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\JwtDecoderProviderConfigurationUtilsTests.java)

Mock Object Variable Name: jwkSource

--- original
+++ refactored
@@
public void getSignatureAlgorithmsWhenJwkSetSpecifiesFamilyThenUses() throws Exception {
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
     // Test parameters are from Anders Rundgren, public only
     ECKey ecKey = new ECKey.Builder(Curve.P_256, new Base64URL("3l2Da_flYc-AuUTm2QzxgyvJxYM_2TeB9DMlwz7j1PE"), new Base64URL("-kjT7Wrfhwsi9SG6H4UXiyUiVE9GHCLauslksZ3-_t0")).keyUse(KeyUse.SIGNATURE).build();
     RSAKey rsaKey = new RSAKey.Builder(TestKeys.DEFAULT_PUBLIC_KEY).keyUse(KeyUse.ENCRYPTION).build();
-    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(Arrays.asList(ecKey, rsaKey));
+    JWKSource<SecurityContext> jwkSource = createMockJwkSource(Arrays.asList(ecKey, rsaKey));
     Set<SignatureAlgorithm> algorithms = JwtDecoderProviderConfigurationUtils.getSignatureAlgorithms(jwkSource);
     assertThat(algorithms).contains(SignatureAlgorithm.ES256, SignatureAlgorithm.ES384, SignatureAlgorithm.ES512);
}

@Test

public void getSignatureAlgorithmsWhenJwkSetSpecifiesFamilyThenUses() throws Exception {

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    // Test parameters are from Anders Rundgren, public only

    ECKey ecKey = new ECKey.Builder(Curve.P_256, new Base64URL("3l2Da_flYc-AuUTm2QzxgyvJxYM_2TeB9DMlwz7j1PE"), new Base64URL("-kjT7Wrfhwsi9SG6H4UXiyUiVE9GHCLauslksZ3-_t0")).keyUse(KeyUse.SIGNATURE).build();

    RSAKey rsaKey = new RSAKey.Builder(TestKeys.DEFAULT_PUBLIC_KEY).keyUse(KeyUse.ENCRYPTION).build();

    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(Arrays.asList(ecKey, rsaKey));

    Set<SignatureAlgorithm> algorithms = JwtDecoderProviderConfigurationUtils.getSignatureAlgorithms(jwkSource);

    assertThat(algorithms).contains(SignatureAlgorithm.ES256, SignatureAlgorithm.ES384, SignatureAlgorithm.ES512);

}

private static JWKSource<SecurityContext> createMockJwkSource(List<RSAKey> keysToReturn) {
    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(keysToReturn);
    return jwkSource;
}

Test Case ID #spring-security_Test_20_3

Test Case Name: getSignatureAlgorithmsWhenAlgorithmThenParses(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\JwtDecoderProviderConfigurationUtilsTests.java)

Mock Object Variable Name: jwkSource

@@
 // gh-9651
 @Test
 public void getSignatureAlgorithmsWhenAlgorithmThenParses() throws Exception {
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
     RSAKey key = new RSAKey.Builder(TestKeys.DEFAULT_PUBLIC_KEY).keyUse(KeyUse.SIGNATURE).algorithm(new Algorithm(JwsAlgorithms.RS256)).build();
-    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(Collections.singletonList(key));
+    JWKSource<SecurityContext> jwkSource = createMockJwkSource(Collections.singletonList(key));
     Set<SignatureAlgorithm> algorithms = JwtDecoderProviderConfigurationUtils.getSignatureAlgorithms(jwkSource);
     assertThat(algorithms).containsOnly(SignatureAlgorithm.RS256);
 }
@@

// gh-9651

@Test

public void getSignatureAlgorithmsWhenAlgorithmThenParses() throws Exception {

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    RSAKey key = new RSAKey.Builder(TestKeys.DEFAULT_PUBLIC_KEY).keyUse(KeyUse.SIGNATURE).algorithm(new Algorithm(JwsAlgorithms.RS256)).build();

    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(Collections.singletonList(key));

    Set<SignatureAlgorithm> algorithms = JwtDecoderProviderConfigurationUtils.getSignatureAlgorithms(jwkSource);

    assertThat(algorithms).containsOnly(SignatureAlgorithm.RS256);

}

private static JWKSource<SecurityContext> createMockJwkSource(List<RSAKey> keysToReturn) {
    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
    given(jwkSource.get(any(JWKSelector.class), isNull())).willReturn(keysToReturn);
    return jwkSource;
}

Mock Clone Instance #spring-security_MCI_21

• Scope: class level
• Mocked Class: com.nimbusds.jose.jwk.source.JWKSource<com.nimbusds.jose.proc.SecurityContext>
• Test Case Count: 3
• MO Count: 3

Reusable Method

public class MockJWKSource {
    /**
     * Creates a mock JWKSource with configurable return value for get(any(), any()).
     *
     * @param jwkList the List of JWKs to return from get(any(), any())
     * @return the configured mock JWKSource
     */
    public static JWKSource<SecurityContext> createMockJwkSource(List<JWK> jwkList) {
        JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
        given(jwkSource.get(any(), any())).willReturn(jwkList);
        return jwkSource;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_21_1

Test Case Name: withJwkSourceWhenDefaultsThenUsesProvidedJwkSource(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\NimbusJwtDecoderTests.java)

Mock Object Variable Name: source

--- original
+++ refactored
@@
public void withJwkSourceWhenDefaultsThenUsesProvidedJwkSource() throws Exception {
-    JWKSource<SecurityContext> source = mock(JWKSource.class);
-    given(source.get(any(), any())).willReturn(JWKSet.parse(JWK_SET).getKeys());
+    JWKSource<SecurityContext> source = MockJWKSource.createMockJwkSource(JWKSet.parse(JWK_SET).getKeys());
    NimbusJwtDecoder decoder = NimbusJwtDecoder.withJwkSource(source).build();
    Jwt jwt = decoder.decode(SIGNED_JWT);
    assertThat(jwt.getClaimAsString("sub")).isEqualTo("test-subject");
}

@Test

public void withJwkSourceWhenDefaultsThenUsesProvidedJwkSource() throws Exception {

    JWKSource<SecurityContext> source = mock(JWKSource.class);

    given(source.get(any(), any())).willReturn(JWKSet.parse(JWK_SET).getKeys());

    NimbusJwtDecoder decoder = NimbusJwtDecoder.withJwkSource(source).build();

    Jwt jwt = decoder.decode(SIGNED_JWT);

    assertThat(jwt.getClaimAsString("sub")).isEqualTo("test-subject");

}

public class MockJWKSource {
    /**
     * Creates a mock JWKSource with configurable return value for get(any(), any()).
     *
     * @param jwkList the List of JWKs to return from get(any(), any())
     * @return the configured mock JWKSource
     */
    public static JWKSource<SecurityContext> createMockJwkSource(List<JWK> jwkList) {
        JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
        given(jwkSource.get(any(), any())).willReturn(jwkList);
        return jwkSource;
    }
}

Test Case ID #spring-security_Test_21_2

Test Case Name: encodeWhenMultipleKeysThenJwkSelectorUsed(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\NimbusJwtEncoderTests.java)

Mock Object Variable Name: jwkSource

@@
    JWK jwk = TestJwks.rsa().algorithm(JWSAlgorithm.RS256).build();
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
-    given(jwkSource.get(any(), any())).willReturn(List.of(jwk, jwk));
+    JWKSource<SecurityContext> jwkSource = MockJWKSource.createMockJwkSource(List.of(jwk, jwk));
    Converter<List<JWK>, JWK> selector = mock(Converter.class);

@Test

public void encodeWhenMultipleKeysThenJwkSelectorUsed() throws Exception {

    JWK jwk = TestJwks.rsa().algorithm(JWSAlgorithm.RS256).build();

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    given(jwkSource.get(any(), any())).willReturn(List.of(jwk, jwk));

    Converter<List<JWK>, JWK> selector = mock(Converter.class);

    given(selector.convert(any())).willReturn(TestJwks.DEFAULT_RSA_JWK);

    NimbusJwtEncoder jwtEncoder = new NimbusJwtEncoder(jwkSource);

    jwtEncoder.setJwkSelector(selector);

    JwtClaimsSet claims = JwtClaimsSet.builder().subject("sub").build();

    jwtEncoder.encode(JwtEncoderParameters.from(claims));

    verify(selector).convert(any());

}

public class MockJWKSource {
    /**
     * Creates a mock JWKSource with configurable return value for get(any(), any()).
     *
     * @param jwkList the List of JWKs to return from get(any(), any())
     * @return the configured mock JWKSource
     */
    public static JWKSource<SecurityContext> createMockJwkSource(List<JWK> jwkList) {
        JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
        given(jwkSource.get(any(), any())).willReturn(jwkList);
        return jwkSource;
    }
}

Test Case ID #spring-security_Test_21_3

Test Case Name: encodeWhenSingleKeyThenJwkSelectorIsNotUsed(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\NimbusJwtEncoderTests.java)

Mock Object Variable Name: jwkSource

@@
     JWK jwk = TestJwks.rsa().algorithm(JWSAlgorithm.RS256).build();
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
-    given(jwkSource.get(any(), any())).willReturn(List.of(jwk));
+    JWKSource<SecurityContext> jwkSource = MockJWKSource.createMockJwkSource(List.of(jwk));
     Converter<List<JWK>, JWK> selector = mock(Converter.class);
     NimbusJwtEncoder jwtEncoder = new NimbusJwtEncoder(jwkSource);
     jwtEncoder.setJwkSelector(selector);
     JwtClaimsSet claims = JwtClaimsSet.builder().subject("sub").build();
     jwtEncoder.encode(JwtEncoderParameters.from(claims));
     verifyNoInteractions(selector);
 }

@Test

public void encodeWhenSingleKeyThenJwkSelectorIsNotUsed() throws Exception {

    JWK jwk = TestJwks.rsa().algorithm(JWSAlgorithm.RS256).build();

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    given(jwkSource.get(any(), any())).willReturn(List.of(jwk));

    Converter<List<JWK>, JWK> selector = mock(Converter.class);

    NimbusJwtEncoder jwtEncoder = new NimbusJwtEncoder(jwkSource);

    jwtEncoder.setJwkSelector(selector);

    JwtClaimsSet claims = JwtClaimsSet.builder().subject("sub").build();

    jwtEncoder.encode(JwtEncoderParameters.from(claims));

    verifyNoInteractions(selector);

}

public class MockJWKSource {
    /**
     * Creates a mock JWKSource with configurable return value for get(any(), any()).
     *
     * @param jwkList the List of JWKs to return from get(any(), any())
     * @return the configured mock JWKSource
     */
    public static JWKSource<SecurityContext> createMockJwkSource(List<JWK> jwkList) {
        JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
        given(jwkSource.get(any(), any())).willReturn(jwkList);
        return jwkSource;
    }
}

Mock Clone Instance #spring-security_MCI_22

• Scope: method level
• Mocked Class: com.nimbusds.jose.jwk.source.JWKSource<com.nimbusds.jose.proc.SecurityContext>
• Test Case Count: 3
• MO Count: 3

Reusable Method

// === Declare in class scope ===
private JWKSource<SecurityContext> jwkSource;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    jwkSource = mock(JWKSource.class);
}

// === Replace local variable in test with ===
jwkSource;

The refactoring details in each test cases

Test Case ID #spring-security_Test_22_1

Test Case Name: jwsKeySelectorWhenNoAlgorithmThenReturnsRS256Selector(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\NimbusJwtDecoderTests.java)

Mock Object Variable Name: jwkSource

@@
 @Test
 public void jwsKeySelectorWhenNoAlgorithmThenReturnsRS256Selector() {
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
+    // removed local mock; replaced with global field `jwkSource`
     JWSKeySelector<SecurityContext> jwsKeySelector = NimbusJwtDecoder.withJwkSetUri(JWK_SET_URI).jwsKeySelector(jwkSource);
     assertThat(jwsKeySelector instanceof JWSVerificationKeySelector);
     JWSVerificationKeySelector<?> jwsVerificationKeySelector = (JWSVerificationKeySelector<?>) jwsKeySelector;
     assertThat(jwsVerificationKeySelector.isAllowed(JWSAlgorithm.RS256)).isTrue();
}

@Test

public void jwsKeySelectorWhenNoAlgorithmThenReturnsRS256Selector() {

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    JWSKeySelector<SecurityContext> jwsKeySelector = NimbusJwtDecoder.withJwkSetUri(JWK_SET_URI).jwsKeySelector(jwkSource);

    assertThat(jwsKeySelector instanceof JWSVerificationKeySelector);

    JWSVerificationKeySelector<?> jwsVerificationKeySelector = (JWSVerificationKeySelector<?>) jwsKeySelector;

    assertThat(jwsVerificationKeySelector.isAllowed(JWSAlgorithm.RS256)).isTrue();

}

// === Declare in class scope ===
private JWKSource<SecurityContext> jwkSource;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    jwkSource = mock(JWKSource.class);
}

// === Replace local variable in test with ===
jwkSource;

Test Case ID #spring-security_Test_22_2

Test Case Name: jwsKeySelectorWhenOneAlgorithmThenReturnsSingleSelector(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\NimbusJwtDecoderTests.java)

Mock Object Variable Name: jwkSource

@@
 @Test
 public void jwsKeySelectorWhenOneAlgorithmThenReturnsSingleSelector() {
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
+    // removed local mock; replaced with global field `jwkSource`
     // @formatter:off
     JWSKeySelector<SecurityContext> jwsKeySelector = NimbusJwtDecoder.withJwkSetUri(JWK_SET_URI).jwsAlgorithm(SignatureAlgorithm.RS512).jwsKeySelector(jwkSource);
     // @formatter:on
     assertThat(jwsKeySelector instanceof JWSVerificationKeySelector);
     JWSVerificationKeySelector<?> jwsVerificationKeySelector = (JWSVerificationKeySelector<?>) jwsKeySelector;
     assertThat(jwsVerificationKeySelector.isAllowed(JWSAlgorithm.RS512)).isTrue();
}

@Test

public void jwsKeySelectorWhenOneAlgorithmThenReturnsSingleSelector() {

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    // @formatter:off

    JWSKeySelector<SecurityContext> jwsKeySelector = NimbusJwtDecoder.withJwkSetUri(JWK_SET_URI).jwsAlgorithm(SignatureAlgorithm.RS512).jwsKeySelector(jwkSource);

    // @formatter:on

    assertThat(jwsKeySelector instanceof JWSVerificationKeySelector);

    JWSVerificationKeySelector<?> jwsVerificationKeySelector = (JWSVerificationKeySelector<?>) jwsKeySelector;

    assertThat(jwsVerificationKeySelector.isAllowed(JWSAlgorithm.RS512)).isTrue();

}

// === Declare in class scope ===
private JWKSource<SecurityContext> jwkSource;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    jwkSource = mock(JWKSource.class);
}

// === Replace local variable in test with ===
jwkSource;

Test Case ID #spring-security_Test_22_3

Test Case Name: jwsKeySelectorWhenMultipleAlgorithmThenReturnsCompositeSelector(File: C:\Java_projects\Spring\spring-security\oauth2\oauth2-jose\src\test\java\org\springframework\security\oauth2\jwt\NimbusJwtDecoderTests.java)

Mock Object Variable Name: jwkSource

@@
 @Test
 public void jwsKeySelectorWhenMultipleAlgorithmThenReturnsCompositeSelector() {
-    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);
+    // removed local mock; replaced with global field `jwkSource`
     // @formatter:off
     JWSKeySelector<SecurityContext> jwsKeySelector = NimbusJwtDecoder.withJwkSetUri(JWK_SET_URI).jwsAlgorithm(SignatureAlgorithm.RS256).jwsAlgorithm(SignatureAlgorithm.RS512).jwsKeySelector(jwkSource);
     // @formatter:on
     assertThat(jwsKeySelector instanceof JWSVerificationKeySelector);
     JWSVerificationKeySelector<?> jwsAlgorithmMapKeySelector = (JWSVerificationKeySelector<?>) jwsKeySelector;
     assertThat(jwsAlgorithmMapKeySelector.isAllowed(JWSAlgorithm.RS256)).isTrue();
     assertThat(jwsAlgorithmMapKeySelector.isAllowed(JWSAlgorithm.RS512)).isTrue();
}

@Test

public void jwsKeySelectorWhenMultipleAlgorithmThenReturnsCompositeSelector() {

    JWKSource<SecurityContext> jwkSource = mock(JWKSource.class);

    // @formatter:off

    JWSKeySelector<SecurityContext> jwsKeySelector = NimbusJwtDecoder.withJwkSetUri(JWK_SET_URI).jwsAlgorithm(SignatureAlgorithm.RS256).jwsAlgorithm(SignatureAlgorithm.RS512).jwsKeySelector(jwkSource);

    // @formatter:on

    assertThat(jwsKeySelector instanceof JWSVerificationKeySelector);

    JWSVerificationKeySelector<?> jwsAlgorithmMapKeySelector = (JWSVerificationKeySelector<?>) jwsKeySelector;

    assertThat(jwsAlgorithmMapKeySelector.isAllowed(JWSAlgorithm.RS256)).isTrue();

    assertThat(jwsAlgorithmMapKeySelector.isAllowed(JWSAlgorithm.RS512)).isTrue();

}

// === Declare in class scope ===
private JWKSource<SecurityContext> jwkSource;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    jwkSource = mock(JWKSource.class);
}

// === Replace local variable in test with ===
jwkSource;

Mock Clone Instance #spring-security_MCI_23

• Scope: class level
• Mocked Class: org.springframework.security.web.csrf.CsrfTokenRepository
• Test Case Count: 2
• MO Count: 2

Reusable Method

public class MockCsrfTokenRepository {
    public static CsrfTokenRepository createMockCsrfTokenRepository(MockHttpServletRequest request, CsrfToken token) {
        CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
        when(csrfTokenRepository.generateToken(request)).thenReturn(token);
        return csrfTokenRepository;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_23_1

Test Case Name: delaySavingCsrf(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\csrf\CsrfAuthenticationStrategyTests.java)

Mock Object Variable Name: csrfTokenRepository

@@
 public void delaySavingCsrf() {
     this.strategy = new CsrfAuthenticationStrategy(new LazyCsrfTokenRepository(this.csrfTokenRepository));
-    given(this.csrfTokenRepository.loadToken(this.request)).willReturn(this.existingToken, (CsrfToken) null);
-    given(this.csrfTokenRepository.generateToken(this.request)).willReturn(this.generatedToken);
+    this.csrfTokenRepository = MockCsrfTokenRepository.createMockCsrfTokenRepository(this.request, this.generatedToken);
+    given(this.csrfTokenRepository.loadToken(this.request)).willReturn(this.existingToken, (CsrfToken) null);
     this.strategy.onAuthentication(new TestingAuthenticationToken("user", "password", "ROLE_USER"), this.request, this.response);
     verify(this.csrfTokenRepository).saveToken(null, this.request, this.response);
     verify(this.csrfTokenRepository, never()).saveToken(eq(this.generatedToken), any(HttpServletRequest.class), any(HttpServletResponse.class));
     CsrfToken tokenInRequest = (CsrfToken) this.request.getAttribute(CsrfToken.class.getName());
     tokenInRequest.getToken();
     verify(this.csrfTokenRepository, times(2)).loadToken(this.request);
     verify(this.csrfTokenRepository).generateToken(this.request);
     verify(this.csrfTokenRepository).saveToken(eq(this.generatedToken), any(HttpServletRequest.class), any(HttpServletResponse.class));
 }

// SEC-2872

@Test

public void delaySavingCsrf() {

    this.strategy = new CsrfAuthenticationStrategy(new LazyCsrfTokenRepository(this.csrfTokenRepository));

    given(this.csrfTokenRepository.loadToken(this.request)).willReturn(this.existingToken, (CsrfToken) null);

    given(this.csrfTokenRepository.generateToken(this.request)).willReturn(this.generatedToken);

    this.strategy.onAuthentication(new TestingAuthenticationToken("user", "password", "ROLE_USER"), this.request, this.response);

    verify(this.csrfTokenRepository).saveToken(null, this.request, this.response);

    verify(this.csrfTokenRepository, never()).saveToken(eq(this.generatedToken), any(HttpServletRequest.class), any(HttpServletResponse.class));

    CsrfToken tokenInRequest = (CsrfToken) this.request.getAttribute(CsrfToken.class.getName());

    tokenInRequest.getToken();

    verify(this.csrfTokenRepository, times(2)).loadToken(this.request);

    verify(this.csrfTokenRepository).generateToken(this.request);

    verify(this.csrfTokenRepository).saveToken(eq(this.generatedToken), any(HttpServletRequest.class), any(HttpServletResponse.class));

}

public class MockCsrfTokenRepository {
    public static CsrfTokenRepository createMockCsrfTokenRepository(MockHttpServletRequest request, CsrfToken token) {
        CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
        when(csrfTokenRepository.generateToken(request)).thenReturn(token);
        return csrfTokenRepository;
    }
}

Test Case ID #spring-security_Test_23_2

Test Case Name: doFilterDoesNotSaveCsrfTokenUntilAccessed(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\csrf\CsrfFilterTests.java)

Mock Object Variable Name: tokenRepository

@@
 public void doFilterDoesNotSaveCsrfTokenUntilAccessed() throws ServletException, IOException {
-    this.filter = createCsrfFilter(new LazyCsrfTokenRepository(this.tokenRepository));
+    this.tokenRepository = MockCsrfTokenRepository.createMockCsrfTokenRepository(this.request, this.token);
+    this.filter = createCsrfFilter(new LazyCsrfTokenRepository(this.tokenRepository));
     given(this.requestMatcher.matches(this.request)).willReturn(false);
-    given(this.tokenRepository.generateToken(this.request)).willReturn(this.token);
     this.filter.doFilter(this.request, this.response, this.filterChain);
     CsrfToken attrToken = (CsrfToken) this.request.getAttribute(this.csrfAttrName);
     // no CsrfToken should have been saved yet
     verify(this.tokenRepository, times(0)).saveToken(any(CsrfToken.class), any(HttpServletRequest.class), any(HttpServletResponse.class));
     verify(this.filterChain).doFilter(this.request, this.response);
     // access the token
     attrToken.getToken();
     // now the CsrfToken should have been saved
     verify(this.tokenRepository).saveToken(eq(this.token), any(HttpServletRequest.class), any(HttpServletResponse.class));
 }
@@

// SEC-2276

@Test

public void doFilterDoesNotSaveCsrfTokenUntilAccessed() throws ServletException, IOException {

    this.filter = createCsrfFilter(new LazyCsrfTokenRepository(this.tokenRepository));

    given(this.requestMatcher.matches(this.request)).willReturn(false);

    given(this.tokenRepository.generateToken(this.request)).willReturn(this.token);

    this.filter.doFilter(this.request, this.response, this.filterChain);

    CsrfToken attrToken = (CsrfToken) this.request.getAttribute(this.csrfAttrName);

    // no CsrfToken should have been saved yet

    verify(this.tokenRepository, times(0)).saveToken(any(CsrfToken.class), any(HttpServletRequest.class), any(HttpServletResponse.class));

    verify(this.filterChain).doFilter(this.request, this.response);

    // access the token

    attrToken.getToken();

    // now the CsrfToken should have been saved

    verify(this.tokenRepository).saveToken(eq(this.token), any(HttpServletRequest.class), any(HttpServletResponse.class));

}

public class MockCsrfTokenRepository {
    public static CsrfTokenRepository createMockCsrfTokenRepository(MockHttpServletRequest request, CsrfToken token) {
        CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
        when(csrfTokenRepository.generateToken(request)).thenReturn(token);
        return csrfTokenRepository;
    }
}

Mock Clone Instance #spring-security_MCI_24

• Scope: method level
• Mocked Class: org.springframework.security.web.csrf.CsrfTokenRepository
• Test Case Count: 4
• MO Count: 4

Reusable Method

private static CsrfTokenRepository createMockCsrfTokenRepository(DeferredCsrfToken deferredCsrfToken) {
    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(deferredCsrfToken);
    return csrfTokenRepository;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_24_1

Test Case Name: getLoginWhenCsrfTokenRequestAttributeHandlerSetThenRespondsWithNormalCsrfToken(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\web\configurers\CsrfConfigurerTests.java)

Mock Object Variable Name: csrfTokenRepository

--- original
+++ refactored
@@
 @Test
 public void getLoginWhenCsrfTokenRequestAttributeHandlerSetThenRespondsWithNormalCsrfToken() throws Exception {
-    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
     CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");
-    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));
+    CsrfTokenRepository csrfTokenRepository = createMockCsrfTokenRepository(new TestDeferredCsrfToken(csrfToken));
     CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;
     CsrfTokenRequestHandlerConfig.HANDLER = new CsrfTokenRequestAttributeHandler();
     this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();
     this.mvc.perform(get("/login")).andExpect(status().isOk()).andExpect(content().string(containsString(csrfToken.getToken())));
     verify(csrfTokenRepository).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));
     verifyNoMoreInteractions(csrfTokenRepository);
 }
@@

@Test

public void getLoginWhenCsrfTokenRequestAttributeHandlerSetThenRespondsWithNormalCsrfToken() throws Exception {

    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);

    CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");

    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));

    CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;

    CsrfTokenRequestHandlerConfig.HANDLER = new CsrfTokenRequestAttributeHandler();

    this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();

    this.mvc.perform(get("/login")).andExpect(status().isOk()).andExpect(content().string(containsString(csrfToken.getToken())));

    verify(csrfTokenRepository).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));

    verifyNoMoreInteractions(csrfTokenRepository);

}

private static CsrfTokenRepository createMockCsrfTokenRepository(DeferredCsrfToken deferredCsrfToken) {
    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(deferredCsrfToken);
    return csrfTokenRepository;
}

Test Case ID #spring-security_Test_24_2

Test Case Name: loginWhenCsrfTokenRequestAttributeHandlerSetAndNormalCsrfTokenThenSuccess(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\web\configurers\CsrfConfigurerTests.java)

Mock Object Variable Name: csrfTokenRepository

@@
     CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");
-    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
-    given(csrfTokenRepository.loadToken(any(HttpServletRequest.class))).willReturn(csrfToken);
-    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));
+    CsrfTokenRepository csrfTokenRepository = createMockCsrfTokenRepository(new TestDeferredCsrfToken(csrfToken));
+    given(csrfTokenRepository.loadToken(any(HttpServletRequest.class))).willReturn(csrfToken);
     CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;
     CsrfTokenRequestHandlerConfig.HANDLER = new CsrfTokenRequestAttributeHandler();
     this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();
     // @formatter:off
     MockHttpServletRequestBuilder loginRequest = post("/login").header(csrfToken.getHeaderName(), csrfToken.getToken()).param("username", "user").param("password", "password");
     // @formatter:on
     this.mvc.perform(loginRequest).andExpect(redirectedUrl("/"));
     verify(csrfTokenRepository).loadToken(any(HttpServletRequest.class));
     verify(csrfTokenRepository).saveToken(isNull(), any(HttpServletRequest.class), any(HttpServletResponse.class));
     verify(csrfTokenRepository, times(2)).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));
     verifyNoMoreInteractions(csrfTokenRepository);
@@

@Test

public void loginWhenCsrfTokenRequestAttributeHandlerSetAndNormalCsrfTokenThenSuccess() throws Exception {

    CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");

    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);

    given(csrfTokenRepository.loadToken(any(HttpServletRequest.class))).willReturn(csrfToken);

    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));

    CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;

    CsrfTokenRequestHandlerConfig.HANDLER = new CsrfTokenRequestAttributeHandler();

    this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();

    // @formatter:off

    MockHttpServletRequestBuilder loginRequest = post("/login").header(csrfToken.getHeaderName(), csrfToken.getToken()).param("username", "user").param("password", "password");

    // @formatter:on

    this.mvc.perform(loginRequest).andExpect(redirectedUrl("/"));

    verify(csrfTokenRepository).loadToken(any(HttpServletRequest.class));

    verify(csrfTokenRepository).saveToken(isNull(), any(HttpServletRequest.class), any(HttpServletResponse.class));

    verify(csrfTokenRepository, times(2)).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));

    verifyNoMoreInteractions(csrfTokenRepository);

}

private static CsrfTokenRepository createMockCsrfTokenRepository(DeferredCsrfToken deferredCsrfToken) {
    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(deferredCsrfToken);
    return csrfTokenRepository;
}

Test Case ID #spring-security_Test_24_3

Test Case Name: getLoginWhenXorCsrfTokenRequestAttributeHandlerSetThenRespondsWithMaskedCsrfToken(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\web\configurers\CsrfConfigurerTests.java)

Mock Object Variable Name: csrfTokenRepository

--- original
+++ refactored
@@
public void getLoginWhenXorCsrfTokenRequestAttributeHandlerSetThenRespondsWithMaskedCsrfToken() throws Exception {
-    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
     CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");
-    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));
+    CsrfTokenRepository csrfTokenRepository = createMockCsrfTokenRepository(new TestDeferredCsrfToken(csrfToken));
     CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;
     CsrfTokenRequestHandlerConfig.HANDLER = new XorCsrfTokenRequestAttributeHandler();
     this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();
     this.mvc.perform(get("/login")).andExpect(status().isOk()).andExpect(content().string(not(containsString(csrfToken.getToken()))));
     verify(csrfTokenRepository).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));
     verifyNoMoreInteractions(csrfTokenRepository);
@@

@Test

public void getLoginWhenXorCsrfTokenRequestAttributeHandlerSetThenRespondsWithMaskedCsrfToken() throws Exception {

    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);

    CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");

    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));

    CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;

    CsrfTokenRequestHandlerConfig.HANDLER = new XorCsrfTokenRequestAttributeHandler();

    this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();

    this.mvc.perform(get("/login")).andExpect(status().isOk()).andExpect(content().string(not(containsString(csrfToken.getToken()))));

    verify(csrfTokenRepository).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));

    verifyNoMoreInteractions(csrfTokenRepository);

}

private static CsrfTokenRepository createMockCsrfTokenRepository(DeferredCsrfToken deferredCsrfToken) {
    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(deferredCsrfToken);
    return csrfTokenRepository;
}

Test Case ID #spring-security_Test_24_4

Test Case Name: loginWhenXorCsrfTokenRequestAttributeHandlerSetAndMaskedCsrfTokenThenSuccess(File: C:\Java_projects\Spring\spring-security\config\src\test\java\org\springframework\security\config\annotation\web\configurers\CsrfConfigurerTests.java)

Mock Object Variable Name: csrfTokenRepository

--- original
+++ refactored
@@
    CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");
-    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
-    given(csrfTokenRepository.loadToken(any(HttpServletRequest.class))).willReturn(csrfToken);
-    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));
+    CsrfTokenRepository csrfTokenRepository = createMockCsrfTokenRepository(new TestDeferredCsrfToken(csrfToken));
+    given(csrfTokenRepository.loadToken(any(HttpServletRequest.class))).willReturn(csrfToken);
    CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;
    CsrfTokenRequestHandlerConfig.HANDLER = new XorCsrfTokenRequestAttributeHandler();
    this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();
    MvcResult mvcResult = this.mvc.perform(get("/login")).andReturn();
    CsrfToken csrfTokenAttribute = (CsrfToken) mvcResult.getRequest().getAttribute(CsrfToken.class.getName());
    // @formatter:off
    MockHttpServletRequestBuilder loginRequest = post("/login").header(csrfToken.getHeaderName(), csrfTokenAttribute.getToken()).param("username", "user").param("password", "password");
    // @formatter:on
    this.mvc.perform(loginRequest).andExpect(redirectedUrl("/"));
    verify(csrfTokenRepository).loadToken(any(HttpServletRequest.class));
    verify(csrfTokenRepository).saveToken(isNull(), any(HttpServletRequest.class), any(HttpServletResponse.class));
    verify(csrfTokenRepository, times(3)).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));
    verifyNoMoreInteractions(csrfTokenRepository);
@@

@Test

public void loginWhenXorCsrfTokenRequestAttributeHandlerSetAndMaskedCsrfTokenThenSuccess() throws Exception {

    CsrfToken csrfToken = new DefaultCsrfToken("X-CSRF-TOKEN", "_csrf", "token");

    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);

    given(csrfTokenRepository.loadToken(any(HttpServletRequest.class))).willReturn(csrfToken);

    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(new TestDeferredCsrfToken(csrfToken));

    CsrfTokenRequestHandlerConfig.REPO = csrfTokenRepository;

    CsrfTokenRequestHandlerConfig.HANDLER = new XorCsrfTokenRequestAttributeHandler();

    this.spring.register(CsrfTokenRequestHandlerConfig.class, BasicController.class).autowire();

    MvcResult mvcResult = this.mvc.perform(get("/login")).andReturn();

    CsrfToken csrfTokenAttribute = (CsrfToken) mvcResult.getRequest().getAttribute(CsrfToken.class.getName());

    // @formatter:off

    MockHttpServletRequestBuilder loginRequest = post("/login").header(csrfToken.getHeaderName(), csrfTokenAttribute.getToken()).param("username", "user").param("password", "password");

    // @formatter:on

    this.mvc.perform(loginRequest).andExpect(redirectedUrl("/"));

    verify(csrfTokenRepository).loadToken(any(HttpServletRequest.class));

    verify(csrfTokenRepository).saveToken(isNull(), any(HttpServletRequest.class), any(HttpServletResponse.class));

    verify(csrfTokenRepository, times(3)).loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class));

    verifyNoMoreInteractions(csrfTokenRepository);

}

private static CsrfTokenRepository createMockCsrfTokenRepository(DeferredCsrfToken deferredCsrfToken) {
    CsrfTokenRepository csrfTokenRepository = mock(CsrfTokenRepository.class);
    given(csrfTokenRepository.loadDeferredToken(any(HttpServletRequest.class), any(HttpServletResponse.class))).willReturn(deferredCsrfToken);
    return csrfTokenRepository;
}

Mock Clone Instance #spring-security_MCI_25

• Scope: method level
• Mocked Class: jakarta.servlet.http.HttpServletRequest
• Test Case Count: 2
• MO Count: 2

Reusable Method

private static HttpServletRequest createMockHttpServletRequest(String forwardPath, RequestDispatcher dispatcher) {
    HttpServletRequest request = mock(HttpServletRequest.class);
    given(request.getRequestDispatcher(forwardPath)).willReturn(dispatcher);
    return request;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_25_1

Test Case Name: resetWhenForward(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\firewall\RequestWrapperTests.java)

Mock Object Variable Name: mockRequest

--- original
+++ refactored
@@
    String denormalizedPath = testPaths.keySet().iterator().next();
    String forwardPath = "/forward/path";
-    HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+    HttpServletRequest mockRequest = createMockHttpServletRequest(forwardPath, mockDispatcher);
    HttpServletResponse mockResponse = mock(HttpServletResponse.class);
    RequestDispatcher mockDispatcher = mock(RequestDispatcher.class);
-    given(mockRequest.getServletPath()).willReturn("");
-    given(mockRequest.getPathInfo()).willReturn(denormalizedPath);
-    given(mockRequest.getRequestDispatcher(forwardPath)).willReturn(mockDispatcher);
+    given(mockRequest.getServletPath()).willReturn("");
+    given(mockRequest.getPathInfo()).willReturn(denormalizedPath);
    RequestWrapper wrapper = new RequestWrapper(mockRequest);
    RequestDispatcher dispatcher = wrapper.getRequestDispatcher(forwardPath);
    dispatcher.forward(mockRequest, mockResponse);
    verify(mockRequest).getRequestDispatcher(forwardPath);
    verify(mockDispatcher).forward(mockRequest, mockResponse);
    assertThat(wrapper.getPathInfo()).isEqualTo(denormalizedPath);
    verify(mockRequest, times(2)).getPathInfo();
    // validate wrapper.getServletPath() delegates to the mock
    wrapper.getServletPath();
    verify(mockRequest, times(2)).getServletPath();
    verifyNoMoreInteractions(mockRequest, mockResponse, mockDispatcher);
@@

@Test

public void resetWhenForward() throws Exception {

    String denormalizedPath = testPaths.keySet().iterator().next();

    String forwardPath = "/forward/path";

    HttpServletRequest mockRequest = mock(HttpServletRequest.class);

    HttpServletResponse mockResponse = mock(HttpServletResponse.class);

    RequestDispatcher mockDispatcher = mock(RequestDispatcher.class);

    given(mockRequest.getServletPath()).willReturn("");

    given(mockRequest.getPathInfo()).willReturn(denormalizedPath);

    given(mockRequest.getRequestDispatcher(forwardPath)).willReturn(mockDispatcher);

    RequestWrapper wrapper = new RequestWrapper(mockRequest);

    RequestDispatcher dispatcher = wrapper.getRequestDispatcher(forwardPath);

    dispatcher.forward(mockRequest, mockResponse);

    verify(mockRequest).getRequestDispatcher(forwardPath);

    verify(mockDispatcher).forward(mockRequest, mockResponse);

    assertThat(wrapper.getPathInfo()).isEqualTo(denormalizedPath);

    verify(mockRequest, times(2)).getPathInfo();

    // validate wrapper.getServletPath() delegates to the mock

    wrapper.getServletPath();

    verify(mockRequest, times(2)).getServletPath();

    verifyNoMoreInteractions(mockRequest, mockResponse, mockDispatcher);

}

private static HttpServletRequest createMockHttpServletRequest(String forwardPath, RequestDispatcher dispatcher) {
    HttpServletRequest request = mock(HttpServletRequest.class);
    given(request.getRequestDispatcher(forwardPath)).willReturn(dispatcher);
    return request;
}

Test Case ID #spring-security_Test_25_2

Test Case Name: requestDispatcherNotWrappedAfterReset(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\firewall\RequestWrapperTests.java)

Mock Object Variable Name: request

@@
    String path = "/forward/path";
-    HttpServletRequest request = mock(HttpServletRequest.class);
    RequestDispatcher dispatcher = mock(RequestDispatcher.class);
-    given(request.getRequestDispatcher(path)).willReturn(dispatcher);
+    HttpServletRequest request = createMockHttpServletRequest(path, dispatcher);
    RequestWrapper wrapper = new RequestWrapper(request);
    wrapper.reset();
    assertThat(wrapper.getRequestDispatcher(path)).isSameAs(dispatcher);
@@

@Test

public void requestDispatcherNotWrappedAfterReset() {

    String path = "/forward/path";

    HttpServletRequest request = mock(HttpServletRequest.class);

    RequestDispatcher dispatcher = mock(RequestDispatcher.class);

    given(request.getRequestDispatcher(path)).willReturn(dispatcher);

    RequestWrapper wrapper = new RequestWrapper(request);

    wrapper.reset();

    assertThat(wrapper.getRequestDispatcher(path)).isSameAs(dispatcher);

}

private static HttpServletRequest createMockHttpServletRequest(String forwardPath, RequestDispatcher dispatcher) {
    HttpServletRequest request = mock(HttpServletRequest.class);
    given(request.getRequestDispatcher(forwardPath)).willReturn(dispatcher);
    return request;
}

Mock Clone Instance #spring-security_MCI_26

• Scope: method level
• Mocked Class: jakarta.servlet.http.HttpServletRequest
• Test Case Count: 7
• MO Count: 7

Reusable Method

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

The refactoring details in each test cases

Test Case ID #spring-security_Test_26_1

Test Case Name: transformThenResultDoesNotDelegateToSetAttribute(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\access\HandlerMappingIntrospectorRequestTransformerTests.java)

Mock Object Variable Name: request

@@
 @Test
 void transformThenResultDoesNotDelegateToSetAttribute() {
-    HttpServletRequest request = mock(HttpServletRequest.class);
+    // removed local mock; replaced with global field `request`
     this.transformer.transform(request);
     ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);
     verify(this.hmi).setCache(requestArg.capture());
     HttpServletRequest transformedRequest = requestArg.getValue();
     String attrName = "any";
     String attrValue = "value";
     transformedRequest.setAttribute(attrName, attrValue);
     verifyNoInteractions(request);
     assertThat(transformedRequest.getAttribute(attrName)).isEqualTo(attrValue);
}

/**

 * The request passed into the transformer does not allow interactions on certain

 * methods, we need to ensure that the methods used by

 * {@link HandlerMappingIntrospector#setCache(HttpServletRequest)} are overridden.

 */

@Test

void transformThenResultDoesNotDelegateToSetAttribute() {

    HttpServletRequest request = mock(HttpServletRequest.class);

    this.transformer.transform(request);

    ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);

    verify(this.hmi).setCache(requestArg.capture());

    HttpServletRequest transformedRequest = requestArg.getValue();

    String attrName = "any";

    String attrValue = "value";

    transformedRequest.setAttribute(attrName, attrValue);

    verifyNoInteractions(request);

    assertThat(transformedRequest.getAttribute(attrName)).isEqualTo(attrValue);

}

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

Test Case ID #spring-security_Test_26_2

Test Case Name: transformThenSetAttributeWorks(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\access\HandlerMappingIntrospectorRequestTransformerTests.java)

Mock Object Variable Name: request

@@
 @Test
 void transformThenSetAttributeWorks() {
-    HttpServletRequest request = mock(HttpServletRequest.class);
+    // removed local mock; replaced with global field `request`
     this.transformer.transform(request);
     ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);
     verify(this.hmi).setCache(requestArg.capture());
     HttpServletRequest transformedRequest = requestArg.getValue();
     String attrName = "any";
     String attrValue = "value";
     transformedRequest.setAttribute(attrName, attrValue);
     assertThat(transformedRequest.getAttribute(attrName)).isEqualTo(attrValue);
}

@Test

void transformThenSetAttributeWorks() {

    HttpServletRequest request = mock(HttpServletRequest.class);

    this.transformer.transform(request);

    ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);

    verify(this.hmi).setCache(requestArg.capture());

    HttpServletRequest transformedRequest = requestArg.getValue();

    String attrName = "any";

    String attrValue = "value";

    transformedRequest.setAttribute(attrName, attrValue);

    assertThat(transformedRequest.getAttribute(attrName)).isEqualTo(attrValue);

}

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

Test Case ID #spring-security_Test_26_3

Test Case Name: transformThenResultDoesNotDelegateToGetAttribute(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\access\HandlerMappingIntrospectorRequestTransformerTests.java)

Mock Object Variable Name: request

@@
 @Test
 void transformThenResultDoesNotDelegateToGetAttribute() {
-    HttpServletRequest request = mock(HttpServletRequest.class);
+    // removed local mock; replaced with global field `request`
     this.transformer.transform(request);
     ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);
     verify(this.hmi).setCache(requestArg.capture());
     HttpServletRequest transformedRequest = requestArg.getValue();
     transformedRequest.getAttribute("any");
     verifyNoInteractions(request);

/**

 * The request passed into the transformer does not allow interactions on certain

 * methods, we need to ensure that the methods used by

 * {@link HandlerMappingIntrospector#setCache(HttpServletRequest)} are overridden.

 */

@Test

void transformThenResultDoesNotDelegateToGetAttribute() {

    HttpServletRequest request = mock(HttpServletRequest.class);

    this.transformer.transform(request);

    ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);

    verify(this.hmi).setCache(requestArg.capture());

    HttpServletRequest transformedRequest = requestArg.getValue();

    transformedRequest.getAttribute("any");

    verifyNoInteractions(request);

}

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

Test Case ID #spring-security_Test_26_4

Test Case Name: transformThenResultDoesNotDelegateToGetAttributeNames(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\access\HandlerMappingIntrospectorRequestTransformerTests.java)

Mock Object Variable Name: request

@@
 */
 @Test
 void transformThenResultDoesNotDelegateToGetAttributeNames() {
-    HttpServletRequest request = mock(HttpServletRequest.class);
+    // removed local mock; replaced with global field `request`
     this.transformer.transform(request);
     ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);
     verify(this.hmi).setCache(requestArg.capture());
     HttpServletRequest transformedRequest = requestArg.getValue();
     transformedRequest.getAttributeNames();
     verifyNoInteractions(request);
}

/**

 * The request passed into the transformer does not allow interactions on certain

 * methods, we need to ensure that the methods used by

 * {@link HandlerMappingIntrospector#setCache(HttpServletRequest)} are overridden.

 */

@Test

void transformThenResultDoesNotDelegateToGetAttributeNames() {

    HttpServletRequest request = mock(HttpServletRequest.class);

    this.transformer.transform(request);

    ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);

    verify(this.hmi).setCache(requestArg.capture());

    HttpServletRequest transformedRequest = requestArg.getValue();

    transformedRequest.getAttributeNames();

    verifyNoInteractions(request);

}

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

Test Case ID #spring-security_Test_26_5

Test Case Name: transformThenGetAttributeNamesWorks(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\access\HandlerMappingIntrospectorRequestTransformerTests.java)

Mock Object Variable Name: request

@@
 @Test
 void transformThenGetAttributeNamesWorks() {
-    HttpServletRequest request = mock(HttpServletRequest.class);
+    // removed local mock; replaced with global field `request`
     this.transformer.transform(request);
     ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);
     verify(this.hmi).setCache(requestArg.capture());
     HttpServletRequest transformedRequest = requestArg.getValue();
     String attrName = "any";
     String attrValue = "value";
     transformedRequest.setAttribute(attrName, attrValue);
     assertThat(Collections.list(transformedRequest.getAttributeNames())).containsExactly(attrName);
}

@Test

void transformThenGetAttributeNamesWorks() {

    HttpServletRequest request = mock(HttpServletRequest.class);

    this.transformer.transform(request);

    ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);

    verify(this.hmi).setCache(requestArg.capture());

    HttpServletRequest transformedRequest = requestArg.getValue();

    String attrName = "any";

    String attrValue = "value";

    transformedRequest.setAttribute(attrName, attrValue);

    assertThat(Collections.list(transformedRequest.getAttributeNames())).containsExactly(attrName);

}

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

Test Case ID #spring-security_Test_26_6

Test Case Name: transformThenResultDoesNotDelegateToRemoveAttribute(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\access\HandlerMappingIntrospectorRequestTransformerTests.java)

Mock Object Variable Name: request

@@
 @Test
 void transformThenResultDoesNotDelegateToRemoveAttribute() {
-    HttpServletRequest request = mock(HttpServletRequest.class);
+    // removed local mock; replaced with global field `request`
     this.transformer.transform(request);
     ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);
     verify(this.hmi).setCache(requestArg.capture());
     HttpServletRequest transformedRequest = requestArg.getValue();
     transformedRequest.removeAttribute("any");
     verifyNoInteractions(request);

/**

 * The request passed into the transformer does not allow interactions on certain

 * methods, we need to ensure that the methods used by

 * {@link HandlerMappingIntrospector#setCache(HttpServletRequest)} are overridden.

 */

@Test

void transformThenResultDoesNotDelegateToRemoveAttribute() {

    HttpServletRequest request = mock(HttpServletRequest.class);

    this.transformer.transform(request);

    ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);

    verify(this.hmi).setCache(requestArg.capture());

    HttpServletRequest transformedRequest = requestArg.getValue();

    transformedRequest.removeAttribute("any");

    verifyNoInteractions(request);

}

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

Test Case ID #spring-security_Test_26_7

Test Case Name: transformThenResultDoesNotDelegateToGetDispatcherType(File: C:\Java_projects\Spring\spring-security\web\src\test\java\org\springframework\security\web\access\HandlerMappingIntrospectorRequestTransformerTests.java)

Mock Object Variable Name: request

@@
 @Test
 void transformThenResultDoesNotDelegateToGetDispatcherType() {
-    HttpServletRequest request = mock(HttpServletRequest.class);
+    // removed local mock; replaced with global field `request`
     this.transformer.transform(request);
     ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);
     verify(this.hmi).setCache(requestArg.capture());
     HttpServletRequest transformedRequest = requestArg.getValue();
     assertThat(transformedRequest.getDispatcherType()).isEqualTo(DispatcherType.REQUEST);
     verifyNoInteractions(request);
}

/**

 * The request passed into the transformer does not allow interactions on certain

 * methods, we need to ensure that the methods used by

 * {@link HandlerMappingIntrospector#setCache(HttpServletRequest)} are overridden.

 */

@Test

void transformThenResultDoesNotDelegateToGetDispatcherType() {

    HttpServletRequest request = mock(HttpServletRequest.class);

    this.transformer.transform(request);

    ArgumentCaptor<HttpServletRequest> requestArg = ArgumentCaptor.forClass(HttpServletRequest.class);

    verify(this.hmi).setCache(requestArg.capture());

    HttpServletRequest transformedRequest = requestArg.getValue();

    assertThat(transformedRequest.getDispatcherType()).isEqualTo(DispatcherType.REQUEST);

    verifyNoInteractions(request);

}

// === Declare in class scope ===
private HttpServletRequest request;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    request = mock(HttpServletRequest.class);
}

// === Replace local variable in test with ===
request

Mock Clone Instance #spring-security_MCI_27

• Scope: method level
• Mocked Class: org.springframework.security.authorization.method.AuthorizationManagerBeforeReactiveMethodInterceptorTests.HandlingReactiveAuthorizationManager
• Test Case Count: 3
• MO Count: 3

Reusable Method

private static HandlingReactiveAuthorizationManager createMockHandlingReactiveAuthorizationManager(MethodInvocation mockMethodInvocation, Mono<?> checkReturnMono) {
    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);
    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(checkReturnMono);
    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockReactiveAuthorizationManager;
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_27_1

Test Case Name: invokeMonoWhenDeniedAndPostProcessorThenInvokePostProcessor(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authorization\method\AuthorizationManagerBeforeReactiveMethodInterceptorTests.java)

Mock Object Variable Name: mockReactiveAuthorizationManager

--- original
+++ refactored
@@
    MethodInvocation mockMethodInvocation = spy(new MockMethodInvocation(new Sample(), Sample.class.getDeclaredMethod("mono")));
    given(mockMethodInvocation.proceed()).willReturn(Mono.just("john"));
-    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);
-    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(Mono.empty());
-    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();
-    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn("***");
+    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = createMockHandlingReactiveAuthorizationManager(mockMethodInvocation, Mono.empty());
+    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn("***");
    AuthorizationManagerBeforeReactiveMethodInterceptor interceptor = new AuthorizationManagerBeforeReactiveMethodInterceptor(Pointcut.TRUE, mockReactiveAuthorizationManager);
    Object result = interceptor.invoke(mockMethodInvocation);
    assertThat(result).asInstanceOf(InstanceOfAssertFactories.type(Mono.class)).extracting(Mono::block).isEqualTo("***");
    verify(mockReactiveAuthorizationManager).check(any(), eq(mockMethodInvocation));
@@

@Test

public void invokeMonoWhenDeniedAndPostProcessorThenInvokePostProcessor() throws Throwable {

    MethodInvocation mockMethodInvocation = spy(new MockMethodInvocation(new Sample(), Sample.class.getDeclaredMethod("mono")));

    given(mockMethodInvocation.proceed()).willReturn(Mono.just("john"));

    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);

    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(Mono.empty());

    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();

    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn("***");

    AuthorizationManagerBeforeReactiveMethodInterceptor interceptor = new AuthorizationManagerBeforeReactiveMethodInterceptor(Pointcut.TRUE, mockReactiveAuthorizationManager);

    Object result = interceptor.invoke(mockMethodInvocation);

    assertThat(result).asInstanceOf(InstanceOfAssertFactories.type(Mono.class)).extracting(Mono::block).isEqualTo("***");

    verify(mockReactiveAuthorizationManager).check(any(), eq(mockMethodInvocation));

}

private static HandlingReactiveAuthorizationManager createMockHandlingReactiveAuthorizationManager(MethodInvocation mockMethodInvocation, Mono<?> checkReturnMono) {
    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);
    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(checkReturnMono);
    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockReactiveAuthorizationManager;
}

Test Case ID #spring-security_Test_27_2

Test Case Name: invokeMonoWhenDeniedAndMonoPostProcessorThenInvokePostProcessor(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authorization\method\AuthorizationManagerBeforeReactiveMethodInterceptorTests.java)

Mock Object Variable Name: mockReactiveAuthorizationManager

--- original
+++ refactored
@@
    MethodInvocation mockMethodInvocation = spy(new MockMethodInvocation(new Sample(), Sample.class.getDeclaredMethod("mono")));
    given(mockMethodInvocation.proceed()).willReturn(Mono.just("john"));
-    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);
-    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(Mono.empty());
-    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();
-    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn(Mono.just("***"));
+    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = createMockHandlingReactiveAuthorizationManager(mockMethodInvocation, Mono.empty());
+    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn(Mono.just("***"));
    AuthorizationManagerBeforeReactiveMethodInterceptor interceptor = new AuthorizationManagerBeforeReactiveMethodInterceptor(Pointcut.TRUE, mockReactiveAuthorizationManager);
    Object result = interceptor.invoke(mockMethodInvocation);
    assertThat(result).asInstanceOf(InstanceOfAssertFactories.type(Mono.class)).extracting(Mono::block).isEqualTo("***");
    verify(mockReactiveAuthorizationManager).check(any(), eq(mockMethodInvocation));
@@

@Test

public void invokeMonoWhenDeniedAndMonoPostProcessorThenInvokePostProcessor() throws Throwable {

    MethodInvocation mockMethodInvocation = spy(new MockMethodInvocation(new Sample(), Sample.class.getDeclaredMethod("mono")));

    given(mockMethodInvocation.proceed()).willReturn(Mono.just("john"));

    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);

    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(Mono.empty());

    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();

    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn(Mono.just("***"));

    AuthorizationManagerBeforeReactiveMethodInterceptor interceptor = new AuthorizationManagerBeforeReactiveMethodInterceptor(Pointcut.TRUE, mockReactiveAuthorizationManager);

    Object result = interceptor.invoke(mockMethodInvocation);

    assertThat(result).asInstanceOf(InstanceOfAssertFactories.type(Mono.class)).extracting(Mono::block).isEqualTo("***");

    verify(mockReactiveAuthorizationManager).check(any(), eq(mockMethodInvocation));

}

private static HandlingReactiveAuthorizationManager createMockHandlingReactiveAuthorizationManager(MethodInvocation mockMethodInvocation, Mono<?> checkReturnMono) {
    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);
    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(checkReturnMono);
    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockReactiveAuthorizationManager;
}

Test Case ID #spring-security_Test_27_3

Test Case Name: invokeFluxWhenDeniedAndPostProcessorThenInvokePostProcessor(File: C:\Java_projects\Spring\spring-security\core\src\test\java\org\springframework\security\authorization\method\AuthorizationManagerBeforeReactiveMethodInterceptorTests.java)

Mock Object Variable Name: mockReactiveAuthorizationManager

--- original
+++ refactored
@@
    MethodInvocation mockMethodInvocation = spy(new MockMethodInvocation(new Sample(), Sample.class.getDeclaredMethod("flux")));
    given(mockMethodInvocation.proceed()).willReturn(Flux.just("john", "bob"));
-    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);
-    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(Mono.empty());
-    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();
-    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn(Mono.just("***"));
+    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = createMockHandlingReactiveAuthorizationManager(mockMethodInvocation, Mono.empty());
+    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn(Mono.just("***"));
    AuthorizationManagerBeforeReactiveMethodInterceptor interceptor = new AuthorizationManagerBeforeReactiveMethodInterceptor(Pointcut.TRUE, mockReactiveAuthorizationManager);
    Object result = interceptor.invoke(mockMethodInvocation);
    assertThat(result).asInstanceOf(InstanceOfAssertFactories.type(Flux.class)).extracting(Flux::collectList).extracting(Mono::block, InstanceOfAssertFactories.list(String.class)).containsExactly("***");
    verify(mockReactiveAuthorizationManager).check(any(), eq(mockMethodInvocation));
@@

@Test

public void invokeFluxWhenDeniedAndPostProcessorThenInvokePostProcessor() throws Throwable {

    MethodInvocation mockMethodInvocation = spy(new MockMethodInvocation(new Sample(), Sample.class.getDeclaredMethod("flux")));

    given(mockMethodInvocation.proceed()).willReturn(Flux.just("john", "bob"));

    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);

    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(Mono.empty());

    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();

    given(mockReactiveAuthorizationManager.handleDeniedInvocation(any(), any(AuthorizationResult.class))).willReturn(Mono.just("***"));

    AuthorizationManagerBeforeReactiveMethodInterceptor interceptor = new AuthorizationManagerBeforeReactiveMethodInterceptor(Pointcut.TRUE, mockReactiveAuthorizationManager);

    Object result = interceptor.invoke(mockMethodInvocation);

    assertThat(result).asInstanceOf(InstanceOfAssertFactories.type(Flux.class)).extracting(Flux::collectList).extracting(Mono::block, InstanceOfAssertFactories.list(String.class)).containsExactly("***");

    verify(mockReactiveAuthorizationManager).check(any(), eq(mockMethodInvocation));

}

private static HandlingReactiveAuthorizationManager createMockHandlingReactiveAuthorizationManager(MethodInvocation mockMethodInvocation, Mono<?> checkReturnMono) {
    HandlingReactiveAuthorizationManager mockReactiveAuthorizationManager = mock(HandlingReactiveAuthorizationManager.class);
    given(mockReactiveAuthorizationManager.check(any(), eq(mockMethodInvocation))).willReturn(checkReturnMono);
    given(mockReactiveAuthorizationManager.authorize(any(), any())).willCallRealMethod();
    return mockReactiveAuthorizationManager;
}

Mock Clone Instance #spring-security_MCI_28

• Scope: method level
• Mocked Class: org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistrationRepository
• Test Case Count: 3
• MO Count: 3

Reusable Method

// === Declare in class scope ===
private RelyingPartyRegistrationRepository registrations;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registrations = mock(RelyingPartyRegistrationRepository.class);
}

// === Replace local variable in test with ===
registrations

The refactoring details in each test cases

Test Case ID #spring-security_Test_28_1

Test Case Name: saml2MetadataResolveWhenNoMatchingRegistrationThenNull(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\test\java\org\springframework\security\saml2\provider\service\metadata\RequestMatcherMetadataResponseResolverTests.java)

Mock Object Variable Name: registrations

@@
@Test
void saml2MetadataResolveWhenNoMatchingRegistrationThenNull() {
-    RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
+    // removed local mock; replaced with global field `registrations`
    RequestMatcherMetadataResponseResolver resolver = new RequestMatcherMetadataResponseResolver(registrations, this.metadataFactory);
    MockHttpServletRequest request = get("/saml2/metadata");
    Saml2MetadataResponse response = resolver.resolve(request);
    assertThat(response).isNull();
}

@Test

void saml2MetadataResolveWhenNoMatchingRegistrationThenNull() {

    RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);

    RequestMatcherMetadataResponseResolver resolver = new RequestMatcherMetadataResponseResolver(registrations, this.metadataFactory);

    MockHttpServletRequest request = get("/saml2/metadata");

    Saml2MetadataResponse response = resolver.resolve(request);

    assertThat(response).isNull();

}

// === Declare in class scope ===
private RelyingPartyRegistrationRepository registrations;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registrations = mock(RelyingPartyRegistrationRepository.class);
}

// === Replace local variable in test with ===
registrations

Test Case ID #spring-security_Test_28_2

Test Case Name: saml2MetadataRegistrationIdResolveWhenNoMatchingRegistrationThenException(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\test\java\org\springframework\security\saml2\provider\service\metadata\RequestMatcherMetadataResponseResolverTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 void saml2MetadataRegistrationIdResolveWhenNoMatchingRegistrationThenException() {
-    RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
+    // removed local mock; replaced with global field `registrations`
     RequestMatcherMetadataResponseResolver resolver = new RequestMatcherMetadataResponseResolver(registrations, this.metadataFactory);
     MockHttpServletRequest request = get("/saml2/metadata/id");
     assertThatExceptionOfType(Saml2Exception.class).isThrownBy(() -> resolver.resolve(request));
}

@Test

void saml2MetadataRegistrationIdResolveWhenNoMatchingRegistrationThenException() {

    RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);

    RequestMatcherMetadataResponseResolver resolver = new RequestMatcherMetadataResponseResolver(registrations, this.metadataFactory);

    MockHttpServletRequest request = get("/saml2/metadata/id");

    assertThatExceptionOfType(Saml2Exception.class).isThrownBy(() -> resolver.resolve(request));

}

// === Declare in class scope ===
private RelyingPartyRegistrationRepository registrations;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registrations = mock(RelyingPartyRegistrationRepository.class);
}

// === Replace local variable in test with ===
registrations

Test Case ID #spring-security_Test_28_3

Test Case Name: resolveWhenRequestDoesNotMatchThenNull(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\test\java\org\springframework\security\saml2\provider\service\metadata\RequestMatcherMetadataResponseResolverTests.java)

Mock Object Variable Name: registrations

@@
@Test
void resolveWhenRequestDoesNotMatchThenNull() {
-    RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
+    // removed local mock; replaced with global field `registrations`
    RequestMatcherMetadataResponseResolver resolver = new RequestMatcherMetadataResponseResolver(registrations, this.metadataFactory);
    assertThat(resolver.resolve(new MockHttpServletRequest())).isNull();
}

@Test

void resolveWhenRequestDoesNotMatchThenNull() {

    RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);

    RequestMatcherMetadataResponseResolver resolver = new RequestMatcherMetadataResponseResolver(registrations, this.metadataFactory);

    assertThat(resolver.resolve(new MockHttpServletRequest())).isNull();

}

// === Declare in class scope ===
private RelyingPartyRegistrationRepository registrations;

// === Add to @BeforeEach method ===
@BeforeEach
public void setUp() {
    registrations = mock(RelyingPartyRegistrationRepository.class);
}

// === Replace local variable in test with ===
registrations

Mock Clone Instance #spring-security_MCI_29

• Scope: class level
• Mocked Class: org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistrationRepository
• Test Case Count: 9
• MO Count: 9

Reusable Method

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_29_1

Test Case Name: saml2LogoutRegistrationIdResolveWhenMatchesThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml4LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     Authentication authentication = new TestingAuthenticationToken("user", "pass");
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);
     assertThat(parameters.getAuthentication()).isEqualTo(authentication);
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");
 }

@Test

void saml2LogoutRegistrationIdResolveWhenMatchesThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);

    Authentication authentication = new TestingAuthenticationToken("user", "pass");

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);

    assertThat(parameters.getAuthentication()).isEqualTo(authentication);

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_2

Test Case Name: saml2LogoutRegistrationIdWhenUnauthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml4LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String registrationId = this.registration.getRegistrationId();
     MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

@Test

void saml2LogoutRegistrationIdWhenUnauthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_3

Test Case Name: saml2LogoutResolveWhenAuthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml4LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     Authentication authentication = TestSaml2Authentications.authentication();
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);
     assertThat(parameters.getAuthentication()).isEqualTo(authentication);
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");
 }

@Test

void saml2LogoutResolveWhenAuthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo");

    Authentication authentication = TestSaml2Authentications.authentication();

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);

    assertThat(parameters.getAuthentication()).isEqualTo(authentication);

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_4

Test Case Name: saml2LogoutRegistrationIdResolveWhenMatchesThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSamlLogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);
     assertThat(parameters.getAuthentication()).isEqualTo(authentication);
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

@Test

void saml2LogoutRegistrationIdResolveWhenMatchesThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);

    Authentication authentication = new TestingAuthenticationToken("user", "pass");

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);

    assertThat(parameters.getAuthentication()).isEqualTo(authentication);

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_5

Test Case Name: saml2LogoutRegistrationIdWhenUnauthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSamlLogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String registrationId = this.registration.getRegistrationId();
     MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");
@@

@Test

void saml2LogoutRegistrationIdWhenUnauthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_6

Test Case Name: saml2LogoutResolveWhenAuthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSamlLogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     Authentication authentication = TestSaml2Authentications.authentication();
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);
     assertThat(parameters.getAuthentication()).isEqualTo(authentication);
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");
 }

@Test

void saml2LogoutResolveWhenAuthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo");

    Authentication authentication = TestSaml2Authentications.authentication();

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);

    assertThat(parameters.getAuthentication()).isEqualTo(authentication);

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_7

Test Case Name: saml2LogoutRegistrationIdResolveWhenMatchesThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml5Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml5LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String registrationId = this.registration.getRegistrationId();
     MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);
     Authentication authentication = new TestingAuthenticationToken("user", "pass");
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);
     assertThat(parameters.getAuthentication()).isEqualTo(authentication);
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");
@@

@Test

void saml2LogoutRegistrationIdResolveWhenMatchesThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);

    Authentication authentication = new TestingAuthenticationToken("user", "pass");

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);

    assertThat(parameters.getAuthentication()).isEqualTo(authentication);

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_8

Test Case Name: saml2LogoutRegistrationIdWhenUnauthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml5Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml5LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String registrationId = this.registration.getRegistrationId();
     MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");
 }

@Test

void saml2LogoutRegistrationIdWhenUnauthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo/" + registrationId);

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_29_9

Test Case Name: saml2LogoutResolveWhenAuthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml5Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml5LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     Authentication authentication = TestSaml2Authentications.authentication();
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");
-    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(registrationId, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);
     assertThat(parameters.getAuthentication()).isEqualTo(authentication);
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");
 }

@Test

void saml2LogoutResolveWhenAuthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo");

    Authentication authentication = TestSaml2Authentications.authentication();

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, "request");

    given(this.registrations.findByRegistrationId(registrationId)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, authentication);

    assertThat(parameters.getAuthentication()).isEqualTo(authentication);

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo("request");

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String registrationId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = Mockito.mock(RelyingPartyRegistrationRepository.class);
        BDDMockito.given(registrations.findByRegistrationId(registrationId)).willReturn(registration);
        return registrations;
    }
}

Mock Clone Instance #spring-security_MCI_30

• Scope: class level
• Mocked Class: org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistrationRepository
• Test Case Count: 6
• MO Count: 6

Reusable Method

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String assertingPartyEntityId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findUniqueByAssertingPartyEntityId(assertingPartyEntityId)).willReturn(registration);
        return registrations;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_30_1

Test Case Name: saml2LogoutResolveWhenUnauthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml4LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());
     String encoded = Saml2Utils.samlEncode(logoutRequest.getBytes(StandardCharsets.UTF_8));
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);
-    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);
 }

@Test

void saml2LogoutResolveWhenUnauthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo");

    String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());

    String encoded = Saml2Utils.samlEncode(logoutRequest.getBytes(StandardCharsets.UTF_8));

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);

    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String assertingPartyEntityId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findUniqueByAssertingPartyEntityId(assertingPartyEntityId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_30_2

Test Case Name: saml2LogoutResolveWhenUnauthenticatedGetRequestThenInflates(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml4LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());
     String encoded = Saml2Utils.samlEncode(Saml2Utils.samlDeflate(logoutRequest));
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);
-    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(
+            TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);
 }

@Test

void saml2LogoutResolveWhenUnauthenticatedGetRequestThenInflates() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = get("/logout/saml2/slo");

    String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());

    String encoded = Saml2Utils.samlEncode(Saml2Utils.samlDeflate(logoutRequest));

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);

    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String assertingPartyEntityId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findUniqueByAssertingPartyEntityId(assertingPartyEntityId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_30_3

Test Case Name: saml2LogoutResolveWhenUnauthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSamlLogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());
     String encoded = Saml2Utils.samlEncode(logoutRequest.getBytes(StandardCharsets.UTF_8));
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);
-    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);
 }

@Test

void saml2LogoutResolveWhenUnauthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo");

    String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());

    String encoded = Saml2Utils.samlEncode(logoutRequest.getBytes(StandardCharsets.UTF_8));

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);

    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String assertingPartyEntityId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findUniqueByAssertingPartyEntityId(assertingPartyEntityId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_30_4

Test Case Name: saml2LogoutResolveWhenUnauthenticatedGetRequestThenInflates(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSamlLogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String registrationId = this.registration.getRegistrationId();
     MockHttpServletRequest request = get("/logout/saml2/slo");
     String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());
     String encoded = Saml2Utils.samlEncode(Saml2Utils.samlDeflate(logoutRequest));
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);
-    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(
+        TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);
 }

@Test

void saml2LogoutResolveWhenUnauthenticatedGetRequestThenInflates() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = get("/logout/saml2/slo");

    String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());

    String encoded = Saml2Utils.samlEncode(Saml2Utils.samlDeflate(logoutRequest));

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);

    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String assertingPartyEntityId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findUniqueByAssertingPartyEntityId(assertingPartyEntityId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_30_5

Test Case Name: saml2LogoutResolveWhenUnauthenticatedThenParameters(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml5Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml5LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());
     String encoded = Saml2Utils.samlEncode(logoutRequest.getBytes(StandardCharsets.UTF_8));
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);
-    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);
 }

@Test

void saml2LogoutResolveWhenUnauthenticatedThenParameters() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = post("/logout/saml2/slo");

    String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());

    String encoded = Saml2Utils.samlEncode(logoutRequest.getBytes(StandardCharsets.UTF_8));

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);

    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String assertingPartyEntityId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findUniqueByAssertingPartyEntityId(assertingPartyEntityId)).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_30_6

Test Case Name: saml2LogoutResolveWhenUnauthenticatedGetRequestThenInflates(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml5Test\java\org\springframework\security\saml2\provider\service\web\authentication\logout\OpenSaml5LogoutRequestValidatorParametersResolverTests.java)

Mock Object Variable Name: registrations

@@
     String registrationId = this.registration.getRegistrationId();
     MockHttpServletRequest request = get("/logout/saml2/slo");
     String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());
     String encoded = Saml2Utils.samlEncode(Saml2Utils.samlDeflate(logoutRequest));
     request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);
-    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(
+        TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID, this.registration);
     Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);
     assertThat(parameters.getAuthentication()).isNull();
     assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);
     assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);

@Test

void saml2LogoutResolveWhenUnauthenticatedGetRequestThenInflates() {

    String registrationId = this.registration.getRegistrationId();

    MockHttpServletRequest request = get("/logout/saml2/slo");

    String logoutRequest = serialize(TestOpenSamlObjects.logoutRequest());

    String encoded = Saml2Utils.samlEncode(Saml2Utils.samlDeflate(logoutRequest));

    request.setParameter(Saml2ParameterNames.SAML_REQUEST, encoded);

    given(this.registrations.findUniqueByAssertingPartyEntityId(TestOpenSamlObjects.ASSERTING_PARTY_ENTITY_ID)).willReturn(this.registration);

    Saml2LogoutRequestValidatorParameters parameters = this.resolver.resolve(request, null);

    assertThat(parameters.getAuthentication()).isNull();

    assertThat(parameters.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(registrationId);

    assertThat(parameters.getLogoutRequest().getSamlRequest()).isEqualTo(encoded);

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(String assertingPartyEntityId, RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findUniqueByAssertingPartyEntityId(assertingPartyEntityId)).willReturn(registration);
        return registrations;
    }
}

Mock Clone Instance #spring-security_MCI_31

• Scope: class level
• Mocked Class: org.springframework.security.saml2.provider.service.registration.RelyingPartyRegistrationRepository
• Test Case Count: 18
• MO Count: 18

Reusable Method

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

The refactoring details in each test cases

Test Case ID #spring-security_Test_31_1

Test Case Name: convertWhenSamlResponseThenToken(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSaml4AuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenSamlResponseThenToken() {
-    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, Saml2Utils.samlEncode("response".getBytes(StandardCharsets.UTF_8)));
     Saml2AuthenticationToken token = converter.convert(request);
     assertThat(token.getSaml2Response()).isEqualTo("response");
     assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());
 }
@@

@Test

public void convertWhenSamlResponseThenToken() {

    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, Saml2Utils.samlEncode("response".getBytes(StandardCharsets.UTF_8)));

    Saml2AuthenticationToken token = converter.convert(request);

    assertThat(token.getSaml2Response()).isEqualTo("response");

    assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_2

Test Case Name: convertWhenSamlResponseInvalidBase64ThenSaml2AuthenticationException(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSaml4AuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenSamlResponseInvalidBase64ThenSaml2AuthenticationException() {
-    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, "invalid");
     assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withCauseInstanceOf(IllegalArgumentException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Failed to decode SAMLResponse"));
 }
@@

@Test

public void convertWhenSamlResponseInvalidBase64ThenSaml2AuthenticationException() {

    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, "invalid");

    assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withCauseInstanceOf(IllegalArgumentException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Failed to decode SAMLResponse"));

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_3

Test Case Name: convertWhenGetRequestThenInflates(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSaml4AuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenGetRequestThenInflates() {
-    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());
     byte[] deflated = Saml2Utils.samlDeflate("response");
     String encoded = Saml2Utils.samlEncode(deflated);
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);
     Saml2AuthenticationToken token = converter.convert(request);
     assertThat(token.getSaml2Response()).isEqualTo("response");
     assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());
 }
@@

@Test

public void convertWhenGetRequestThenInflates() {

    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());

    byte[] deflated = Saml2Utils.samlDeflate("response");

    String encoded = Saml2Utils.samlEncode(deflated);

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);

    Saml2AuthenticationToken token = converter.convert(request);

    assertThat(token.getSaml2Response()).isEqualTo("response");

    assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_4

Test Case Name: convertWhenGetRequestInvalidDeflatedThenSaml2AuthenticationException(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSaml4AuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenGetRequestInvalidDeflatedThenSaml2AuthenticationException() {
-    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());
     byte[] invalidDeflated = "invalid".getBytes();
     String encoded = Saml2Utils.samlEncode(invalidDeflated);
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);
     assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withRootCauseInstanceOf(IOException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Unable to inflate string"));
 }
@@

@Test

public void convertWhenGetRequestInvalidDeflatedThenSaml2AuthenticationException() {

    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());

    byte[] invalidDeflated = "invalid".getBytes();

    String encoded = Saml2Utils.samlEncode(invalidDeflated);

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);

    assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withRootCauseInstanceOf(IOException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Unable to inflate string"));

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_5

Test Case Name: convertWhenUsingSamlUtilsBase64ThenXmlIsValid(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSaml4AuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenUsingSamlUtilsBase64ThenXmlIsValid() throws Exception {
-    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, getSsoCircleEncodedXml());
     Saml2AuthenticationToken token = converter.convert(request);
     validateSsoCircleXml(token.getSaml2Response());
 }
@@

@Test

public void convertWhenUsingSamlUtilsBase64ThenXmlIsValid() throws Exception {

    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, getSsoCircleEncodedXml());

    Saml2AuthenticationToken token = converter.convert(request);

    validateSsoCircleXml(token.getSaml2Response());

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_6

Test Case Name: convertWhenSavedAuthenticationRequestThenToken(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSaml4AuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

--- Original
+++ Refactored
@@
    AbstractSaml2AuthenticationRequest authenticationRequest = mock(AbstractSaml2AuthenticationRequest.class);
    given(authenticationRequest.getRelyingPartyRegistrationId()).willReturn(this.registration.getRegistrationId());
-    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
-    converter.setAuthenticationRequestRepository(authenticationRequestRepository);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);
+    converter.setAuthenticationRequestRepository(authenticationRequestRepository);
    given(authenticationRequestRepository.loadAuthenticationRequest(any(HttpServletRequest.class))).willReturn(authenticationRequest);
    MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());
    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, Saml2Utils.samlEncode("response".getBytes(StandardCharsets.UTF_8)));
    Saml2AuthenticationToken token = converter.convert(request);
    assertThat(token.getSaml2Response()).isEqualTo("response");
    assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());
    assertThat(token.getAuthenticationRequest()).isEqualTo(authenticationRequest);
@@

@Test

public void convertWhenSavedAuthenticationRequestThenToken() {

    Saml2AuthenticationRequestRepository<AbstractSaml2AuthenticationRequest> authenticationRequestRepository = mock(Saml2AuthenticationRequestRepository.class);

    AbstractSaml2AuthenticationRequest authenticationRequest = mock(AbstractSaml2AuthenticationRequest.class);

    given(authenticationRequest.getRelyingPartyRegistrationId()).willReturn(this.registration.getRegistrationId());

    OpenSaml4AuthenticationTokenConverter converter = new OpenSaml4AuthenticationTokenConverter(this.registrations);

    converter.setAuthenticationRequestRepository(authenticationRequestRepository);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    given(authenticationRequestRepository.loadAuthenticationRequest(any(HttpServletRequest.class))).willReturn(authenticationRequest);

    MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, Saml2Utils.samlEncode("response".getBytes(StandardCharsets.UTF_8)));

    Saml2AuthenticationToken token = converter.convert(request);

    assertThat(token.getSaml2Response()).isEqualTo("response");

    assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());

    assertThat(token.getAuthenticationRequest()).isEqualTo(authenticationRequest);

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_7

Test Case Name: convertWhenSamlResponseThenToken(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSamlAuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenSamlResponseThenToken() {
-    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, Saml2Utils.samlEncode("response".getBytes(StandardCharsets.UTF_8)));
     Saml2AuthenticationToken token = converter.convert(request);
     assertThat(token.getSaml2Response()).isEqualTo("response");
     assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());
 }
@@

@Test

public void convertWhenSamlResponseThenToken() {

    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, Saml2Utils.samlEncode("response".getBytes(StandardCharsets.UTF_8)));

    Saml2AuthenticationToken token = converter.convert(request);

    assertThat(token.getSaml2Response()).isEqualTo("response");

    assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_8

Test Case Name: convertWhenSamlResponseInvalidBase64ThenSaml2AuthenticationException(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSamlAuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenSamlResponseInvalidBase64ThenSaml2AuthenticationException() {
-    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, "invalid");
     assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withCauseInstanceOf(IllegalArgumentException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Failed to decode SAMLResponse"));
 }

@Test

public void convertWhenSamlResponseInvalidBase64ThenSaml2AuthenticationException() {

    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, "invalid");

    assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withCauseInstanceOf(IllegalArgumentException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Failed to decode SAMLResponse"));

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_9

Test Case Name: convertWhenGetRequestThenInflates(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSamlAuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenGetRequestThenInflates() {
-    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());
     byte[] deflated = Saml2Utils.samlDeflate("response");
     String encoded = Saml2Utils.samlEncode(deflated);
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);
     Saml2AuthenticationToken token = converter.convert(request);
     assertThat(token.getSaml2Response()).isEqualTo("response");
     assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());
 }
@@

@Test

public void convertWhenGetRequestThenInflates() {

    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());

    byte[] deflated = Saml2Utils.samlDeflate("response");

    String encoded = Saml2Utils.samlEncode(deflated);

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);

    Saml2AuthenticationToken token = converter.convert(request);

    assertThat(token.getSaml2Response()).isEqualTo("response");

    assertThat(token.getRelyingPartyRegistration().getRegistrationId()).isEqualTo(this.registration.getRegistrationId());

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_10

Test Case Name: convertWhenGetRequestInvalidDeflatedThenSaml2AuthenticationException(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSamlAuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

--- Original
+++ Refactored
@@
 @Test
 public void convertWhenGetRequestInvalidDeflatedThenSaml2AuthenticationException() {
-    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());
     byte[] invalidDeflated = "invalid".getBytes();
     String encoded = Saml2Utils.samlEncode(invalidDeflated);
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);
     assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withRootCauseInstanceOf(IOException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Unable to inflate string"));
 }
@@

@Test

public void convertWhenGetRequestInvalidDeflatedThenSaml2AuthenticationException() {

    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);

    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);

    MockHttpServletRequest request = get("/login/saml2/sso/" + this.registration.getRegistrationId());

    byte[] invalidDeflated = "invalid".getBytes();

    String encoded = Saml2Utils.samlEncode(invalidDeflated);

    request.setParameter(Saml2ParameterNames.SAML_RESPONSE, encoded);

    assertThatExceptionOfType(Saml2AuthenticationException.class).isThrownBy(() -> converter.convert(request)).withRootCauseInstanceOf(IOException.class).satisfies((ex) -> assertThat(ex.getSaml2Error().getErrorCode()).isEqualTo(Saml2ErrorCodes.INVALID_RESPONSE)).satisfies((ex) -> assertThat(ex.getSaml2Error().getDescription()).isEqualTo("Unable to inflate string"));

}

public class MockRelyingPartyRegistrationRepository {
    public static RelyingPartyRegistrationRepository createMockRelyingPartyRegistrationRepository(RelyingPartyRegistration registration) {
        RelyingPartyRegistrationRepository registrations = mock(RelyingPartyRegistrationRepository.class);
        given(registrations.findByRegistrationId(any())).willReturn(registration);
        return registrations;
    }
}

Test Case ID #spring-security_Test_31_11

Test Case Name: convertWhenUsingSamlUtilsBase64ThenXmlIsValid(File: C:\Java_projects\Spring\spring-security\saml2\saml2-service-provider\src\opensaml4Test\java\org\springframework\security\saml2\provider\service\web\OpenSamlAuthenticationTokenConverterTests.java)

Mock Object Variable Name: registrations

@@
 @Test
 public void convertWhenUsingSamlUtilsBase64ThenXmlIsValid() throws Exception {
-    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
-    given(this.registrations.findByRegistrationId(any())).willReturn(this.registration);
+    this.registrations = MockRelyingPartyRegistrationRepository.createMockRelyingPartyRegistrationRepository(this.registration);
+    OpenSamlAuthenticationTokenConverter converter = new OpenSamlAuthenticationTokenConverter(this.registrations);
     MockHttpServletRequest request = post("/login/saml2/sso/" + this.registration.getRegistrationId());
     request.setParameter(Saml2ParameterNames.SAML_RESPONSE, getSsoCircleEncodedXml());
     Saml2AuthenticationToken token = converter.convert(request);
     validateSsoCircleXml(token.getSaml2Response());
 }
@@